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 project aims to develop a web-based administrative interface for istSOS, focussed on simplify the management and monitoring of SensorThings API components. The project will provide an intuitive method for log new sensors and devices, configuring metadata, and real-time tracking key sensor metrics, including received data, transmission delays, and overall system performance. This will also enhance usability, getting rid of comple API interactions, making istSOS more accessible to researchers, engineers, and IoT enthusiasts. Currently, the istSOS’ graphical interface appears outdated and not aligned with modern software standards. My project will also focus on updating the visual appearance and usability of the interface to enhance the user experience and make the system more accessible and simple to use. All the code will be followed with detailed comments and documentation, making future maintenance easier.
DFlow is a tool designed to simplify the process of creating conversational models for virtual assistants. It aims to solve the problem of manual intent example creation in virtual assistant development. VAs require a set of examples of user intents to understand and respond to user queries correctly. However, manually creating these examples can be time consuming and vulnerable to errors, so the project has two objectives: 1. Develop a M2M transformation tool that can automatically generate intent examples from OpenAPI descriptions. 2. Automate the creation of intent examples from OpenAPI descriptions directly in the dflow platform. By achieving these objectives, dflow can make the VA development process much easier, saving time and effort for developers. The deliverables of this project include a functional M2M transformation tool and an automated intent example creation feature in the dflow platform.
<p>This proposal concerns the addition of pose data extraction using OpenPose and the generation of posture and gesture embeddings to Red Hen’s pipelines for processing the NewsScape datasets, and posture and gesture search by example and similarity search to the vitrivr video information retrieval software. The focus is on reorienting some of the existing work towards similarity search in a pilot production environment. Embeddings for static body and hand poses will be created using Spatial (Non-Temporal) Graph Convolutional Networks using triplet loss. Candidates for illustrative gestures will be segmented based upon manually engineered features on skeletons from OpenPose and then embedded using Spatial Temporal Graph Convolutional Networks combined with triplet loss. Functionality for querying using a webcam will be added to vitrivr, and the embedding pipeline will be integrated into cineast</p>
<p>At CERN, the data from LHC collisions requires complex data types and functions to be processed. As a solution, the awkward-array library makes python implementation of these data types possible in a way which is portable to GPUs. Making this library work through C++ code would give it the ability to have precompiled C++ routines for faster implementation (past the initial load time) and later compatibility with vectorization primitives from C++ libraries.</p> <p>As part of this project, I will be working on expanding the awkward-array python library to include C++ compatible functions using pybind11. This will entail creating compiled C++ code in the form of python extension modules to be an expansion of the already-existing package. The classes I will be writing will be C++/python versions of the classes which have been already written in the main directory of the awkward-array project.</p>
This project aims to enhance EvalAI's functionalities by automating large worker deployments in AWS, adding relevant features for efficient challenge management and also writing a robust and efficient test suite. The focus of the project is: To automate large worker deployment processes on EvalAI using AWS EC2 instances, reducing infrastructure running costs. Make challenge management seamless and less reliant on the admins reducing the dependency of challenge hosts on EvalAI admins. To make EvalAI more reliable and error-free by incorporating tests for different frontend and backend components. Having robust tests prevents making code-breaking changes to the codebase. This task will include adding unit tests for the API suite, prediction upload evaluation workers, code upload evaluation workers (on EKS), and integration tests for end-to-end testing of all components.
<p>Zulip-terminal is the official terminal client for Zulip which has been actively developing for the past few years and has already reached a certain level where it’s no longer considered a temporary client. It still has a long way to go to match the level of web-app, in terms of feature enhancements. So, my primary objective this summer would be to provide more feature support to Zulip-terminal and improve upon the existing ones by fixing bugs and potentially adding and improving upon the test suite. Some of the highlights of the work that I'll be doing:</p> <ul> <li>Adding support for Alert word handling. (events and UI)</li> <li>Improving zuliprc location/specifying.</li> <li>Adding support for specifying custom key-bindings</li> <li>Adding support for cross-platform notifications.</li> <li>Message rendering and event handling improvements.</li> </ul>
<p>The VCF (Variant Call Format) is a format for text files, which is generally stored in a compressed manner to make the data retrieval of variants fast. The data which is redundant is not stored, only the variations are stored. VCF files are used to store all variant types which includes single nucleotide polymorphism (SNP) in a specific position of the genome, short insertions and deletions (INDEL) and structural variants (SV). VCF-validator includes various checks to ensure that the VCF file is consistent. It is based on a formal grammar and performs lexical, syntactic, and semantic analysis of the VCF file. It also includes a tool called VCF-debugulator which fixes errors such as the presence of duplicate variants automatically. SNPs and INDELs are fully supported in VCF-validator, but the support for SVs is still limited. The aim of this project is to improve the support for structural variants in the validator and the debugulator.</p>
This project studies the development of a tiny worm called Caenorhabditis elegans, focusing on how its cells grow and interact from its early stages. It uses two special tools called Spatial Hypergraphs and Lineage Hypergraphs to map out and understand these interactions. Spatial Hypergraphs look at how cells are arranged and interact in space, which helps us understand how they communicate and influence each other. Lineage Hypergraphs track the family tree of each cell, showing how cells evolve and form different parts of the worm's body. By combining these tools, the project aims to get a complete picture of the worm's development, from a single cell to a fully formed organism. This work could help us learn more about basic life processes and improve medical and tissue engineering fields. The project is supported by international organizations interested in neuroscience and the use of advanced computer models to study brain and nervous system development.
The Peersky browser currently lacks a unified system for managing both user-installed WebExtensions and core browser preferences. This project will implement full WebExtension support alongside a customizable peersky://settings page, creating a modular and privacy-focused experience within Peersky’s Electron-based environment. Deliverables include support for installing .zip and Git-based extensions, a persistent extension loader, Manifest V3 validation, CSP-based sandboxing, and a toolbar for pinning and managing extensions. The settings page will also allow users to change themes, set search engines, configure the home page, and manage built-in privacy tools like uBlock Origin and DScan. By the end of the project, Peersky will support a secure, extensible, and decentralized customization system—without relying on centralized extension stores.
Mixxx currently allows assigning a single free-text genre to each track, which often leads to inconsistencies such as duplicate or fragmented categories (e.g., "Hip-Hop", "Hip Hop", "Hiphop"). This project proposes a complete rework of genre metadata handling, introducing three key features: local genre autocompletion with fuzzy matching, support for assigning multiple genres to a single track, and optional online genre suggestions using MusicBrainz and Discogs APIs. As a long-term extension, the project also explores a customizable genre mapping layer, enabling users to define how external genres are grouped or renamed according to personal preferences. Deliverables include: a redesigned genre database schema, enhanced UI for editing and filtering genres, API integration for genre lookups, and internal tools for mapping and translation of genre labels.
WasmEdge is a leading WebAssembly runtime for AI inference. It supports AI frameworks such as Tensorflow, OpenVINO and PyTorch. A compelling use case is computer vision applications on the edge. Computer vision applications need to pre-process images and videos into tensor formats before applying the AI model. They then often need to overlay the tensor results onto the original image. In our existing demos, we use the Rust [image crate](https://crates.io/crates/image) to process images. However, the crate only has limited features and is inadequate for many computer vision applications. In the Python-based computer vision applications, the image pre-processing is often done with the Python wrapper for OpenCV library. The OpenCV library itself is written in C and can be compiled into WebAssembly. We would like to create an OpenCV SDK that allows WebAssembly applications to call OpenCV functions.
The Active Segmentation platform for ImageJ (ASP/IJ) was developed in the scope of GSOC 2016 - 2021. The plugin provides a general-purpose environment that allows biologists and other domain experts to use transparently state-of-the-art techniques in machine learning to achieve excellent image segmentation and classification. ImageJ is a public-domain Java image processing program extensively used in life and material sciences. The program was designed with an open architecture that provides extensibility via plugins computing different filters and region descriptors (i.e. image features). The feature space and the classification results produced by the platform are stored in several separate files. The idea is that the types and values of image features and classification outcomes would be stored in an SQLite database for cross-comparisons between sessions. The candidate is required to use the SQLite database engine in order to integrate it with the GUI of ASP/IJ.
NodeCloud is an API for the open cloud and acts as a package to abstract away the specifics of implementation for multiple cloud providers, as a developer it then becomes relatively easier to leverage cloud services without getting bogged down with the specifics of the individual cloud providers. The current implementation of NodeCloud is a core library that supports AWS, Azure, GCP and DigitalOcean cloud services as extensible plugins, along with an automatic class implementation generator that is built by leveraging the TypeScript compiler API. The aim is to extend this plugin functionality built into NodeCloud to include another emerging cloud provider i.e. Alibaba Cloud, also known as Aliyun, is a cloud computing company, a subsidiary of Alibaba Group. I aim to implement the core functionalities of the AliCloud platform in a suitable SDK, implement a code generation module for that and then use that SDK to auto-generate classes, assembled as the alicloud-plugin.
This GSoC project focuses on strengthening SymPy's assumptions system through a two-fold approach. The first component targets relational reasoning by addressing key inference gaps, without needing explicit real assumptions. Additionally, it involves integrating an incremental SAT solver to significantly improve the performance of ask and satask by enabling clause reuse across queries. The second part of the project introduces support for quantified logical reasoning. By implementing universal and existential quantifiers (Q.forall, Q.exists), SymPy users will be able to express and evaluate rich, domain-spanning mathematical statements. This will be realized using a hybrid strategy, combining Z3-style pattern-based instantiation with SymPy's symbolic, declarative assumptions system. Together, these enhancements aim to make SymPy's logic engine more expressive, efficient, and mathematically powerful.
This project transforms API Dash into a next-generation, AI-native API client. I am merging three core objectives: 1. Agentic API Testing, 2. MCP Support 3. Generative UI Visualizations into a unified Dual-Transport Model Context Protocol (MCP) Architecture: 1. Agentic Sandbox & Generative UI (GenUI): Eliminating brittle WebViews, the internal UI will utilize Google's genui SDK and the Open Responses specification. This powers two features: an autonomous, self-healing Agentic Testing Dashboard, and a "Generative UI Previewer" that visualizes rich AI responses for end-users building Flutter/Web apps. 2. Headless MCP Engine: This exposes API Dash as a standard stdio MCP Server for external Agent interfaces (like VS Code, Cursor, or Claude Desktop).
As part of the Google Summer of Code 2023 , we developed an automated testing harness suite for the official PostgreSQL website. The suite addresses the challenge of manually debugging bugs in the website, which could take hours of trial and error to identify the root cause. By automating the debugging process, the testing suite can significantly reduce the time it takes to identify and fix bugs, improving the overall quality of the website. The suite utilizes the amazing abilities of Django Framework and Selenium webdriver to generate easy to work with logs. The testing suite is designed to test all aspects of the website, including the user interface, the database, and the back-end code. It uses a variety of techniques to test the website, including unit testing, integration testing, and system testing. The testing suite is also designed to be extensible, so that it can be easily updated to test new features and changes to the website.
In Bayesian statistics, one way to circumvent positing parametric assumptions is to use Dirichlet Processes (DP) as priors for probability distributions themselves. PyMC is a Python probabilistic programming library for Bayesian modelling and there are ongoing efforts to add a DP functionality to the package. DPs are daunting both theoretically and computationally as their non-trivial implementation would benefit from polished non-user facing methods in Aesara - formerly Theano - and AePPL. The former provides the computational backend to PyMC whereas AePPL converts arbitrary Aesara graphs into equivalent log-probability graphs which are convenient for automatic differentiation and hence sampling. The goals of my proposed Google Summer of Code (GSoC) project are threefold: relax the univariate assumption of components in mixture models, allow the creation of mixture graph via IfElse and Switch statements and continue ongoing efforts to add a DP functionality to PyMC.
Jitsi Meet’s current whiteboard—built on an outdated Excalidraw fork and Socket.IO v2.5—only supports basic “smart objects,” lacks file/image upload, and suffers from performance and maintenance challenges. This project will: Upgrade real‑time transport by moving to Socket.IO 4.x and optimizing WebSocket message flow (batching, compression) for lower latency. Migrate to the latest Excalidraw release, ensuring full compatibility with Jitsi Meet and access to new drawing features. Implement a pluggable storage backend (starting with MiniIO) so users can share files directly on the whiteboard. Deliverables: -A collaboration server upgraded to Socket.IO 4.x with measurable performance gains -An updated Jitsi whiteboard using the newest Excalidraw version -A modular storageBackend abstraction plus working MiniIO module
Valhalla is a routing engine built on OpenStreetMap data, that allows for high flexibility by providing diverse routing modes and routing filters. Initially, Valhalla received transit data from Transitland API, which converts GTFS (General Transit Feed Specification) data into a database. However, Transitland data is no longer compatible with Valhalla due to their internal updates. To bring back transit routing support to Valhalla and make it less reliant on third-party software, it can receive transit data from GTFS directly. There are downsides of simply updating the code for Transitland: (a) it is dependent on OpenstreetMap, making Valhalla heavier, while GTFS can be independent, (b) Valhalla is still vulnerable to future changes in Transitland code that may break the code. Therefore, this proposal is for an independent integration of transit data from RAW GTFS, rather than being dependent on a third-party platform.
<p>NodeCloud is a <strong>NodeJs package</strong> that aims to provide a one-stop solution to use multiple cloud providers in a project. It provides a plugin for each cloud provider which will be used to communicate with respective cloud services. Currently, the nodecloud project has aws, azure, and gcp integrated with an auto class generator(<strong>Made using Typescript Compiler API</strong>). But for the digital ocean, this has not been implemented. Digital Ocean does not have any official SDKs but there are many third-party SDK's made by developers. Some SDKs are of no use as there are either definition files missing while some are not maintained.</p> <p>Under this project, I aim to implement the important functionalities of the digital ocean in a suitable SDK(If not present), <strong>Implement a code generation module for that</strong> and then use that SDK to auto-generate classes, assembled as <strong>do-plugin</strong> for the <strong>Nodecloud integration</strong>.</p>
<p>The goal of this project is to add several recently developed spatial estimators to the exploratory spatial data analysis (esda) submodule of PySAL, the Python Spatial Analysis Library. This project will allow researchers to easily deploy these estimators in existing spatial workflows. Specifically, this project will contribute implementation, docstrings, tests, and example notebooks for (1) bivariate local join count statistics, (2) multivariate local join count statistics, and (3) local spatial heteroskedasticity (LOSH) statistics. In the first phase of this project, each estimator will be reviewed and pseudo-coded to identify areas of optimization. In the second phase, the estimators will be implemented with tests, with performance assessed against spatial datasets of different sizes. In the final phase, example notebooks will be drafted and polished to a quality ready for external (e.g. workshop) use.</p>
The current Continuum Mechanics module is very useful and has been developed to a good extent. However, there are many more concepts that are prevalent in the field of Solid Mechanics and have not been implemented in SymPy. This project aims to implement some new classes that would bring these utilities into the module. This way a wider range of engineering problems can be solved using SymPy. The two features that are planned to be implemented are solving Torsional problems due to the presence of torque along the direction of the shaft and calculating internal forces & reactions for a given Truss under external forces and moments. This project also plans to add some functions to the geometry module to add some flexibility to the way one can form composite shapes so that it is easier to define complex cross-sectional geometries for the beam module. Implementing the above-mentioned features will expand SymPy to a great extent and help users solve a wider range of problems with ease and precision.
Implement rust wrapper around aries-vcx to enable consuming the library in mobile setting using modern FFI approach using uniffi library. Additionally implement aries mediator client to unlock full mobile support. Learning Objectives - Learn about self sovereign identity and Aries protocols - Learn Rust language - Learn basics of Kotlin language, basics of Android development - Learn Github Actions and CI process in general - Learn about FFI (Foreign Function Interface) by using uniffi library Expected Outcome - uniffi_aries_vcx rust crate which generate mobile bindings for aries-vcx library - implement mediator client with aries message pick-up protocol support - simple android demo application which can be run in simulator - CI job to build Kotlin and iOS bindings, CI job to test the wrapper
This project focuses on making SymPy's assumptions system more robust, efficient, and reliable through a three component architectural upgrade. The first component introduces a backend solver for Equality Logic and Uninterpreted Functions (EUF) directly into the SAT engine. The second component upgrades the Linear Real Arithmetic (LRA) solver to safely handle complex domains, irrational boundary limits, and symbolic infinities (like oo) without failing while also refactoring the core ask dispatcher to resolve many recursion loops during query evaluation. Last component, the project will replace thousands of hardcoded static unit tests with dynamic, property-based tests using the Hypothesis library. By automatically generating complex mathematical trees to find hidden bugs, these enhancements will smooth out the rough edges of the assumptions module, making it a significantly faster and mathematically stronger.