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.
<p>MediaCMS is a modern, fully-featured open-source video and media CMS. It is developed to meet the needs of modern web platforms for viewing and sharing media. It can be used to build a small to medium video and media portal within minutes.</p> <p>It is built mostly using the modern stack Django + React, Celery and includes a REST API. MediaCMS is a very useful project empowering communities around the globe to host their own media and content management system. It also helps educational institutes to manage their media and course curriculum by supporting various media formats like Video, Audio, PDF. Docs, etc.</p> <p>This project aims to improve on some of the core features of the MediaCMS:</p> <ul> <li>Revamping the uploader dashboard with analytics in focus</li> <li>Creation of command-line client for Rest API</li> <li>Improve on the software internalization (i18n)</li> <li>Implement Block Storage Support</li> <li>Implement remote encoding services</li> <li>Improvements to System Notifications</li> <li>Create an admin dashboard</li> </ul>
SODA API is an open source implementation of SODA API Standards for Data and Storage Management. The effort is to provide a common unified data and storage interface to store, run any data anywhere. This project implements the API Server, Different API services, utilities and more. The implementation will be based on the API standards from The SODA Foundation. It connects the application or client to the storage backends to do data/storage management seamlessly providing a platform and storage agnostic framework. Any application or client platform can implement the interface using the API specification to connect to API or implement northbound plugins to bridge their specifications to SODA API. Currently we support block and file APIs for key features of data management (provisioning, migration, fileshare, etc). for on-prem implementation This is one of the SODA Core Projects and is maintained by SODA Foundation directly. Provides the standardization for Data / Storage Management APIs. Currently we support block and file APIs for key features of data management (provisioning, migration, fileshare, etc). Working to add the storage management APIs. This is the key external interface to platforms, which can do a seamless integration with heterogeneous storage backends.
Linux profiling tool a.k.a perf is the home for analyzing the entire system. It provides the support to analyze the stacks end to end leading from hardware events such as instructions executed, cache-misses suffered, or branches mispredicted to software events such as CPU-clock, page-faults, task-CPU etc. The linux perf tools help us to point out exactly where the specific event is leading to performance downturn in kernel, BPF or userspace application. The increasing demand for consolidation due to the bloom in fields of AI and the cloud technology requires increased efforts to provide best performance for novel devices. As software systems become increasingly complex, identifying and resolving performance bottlenecks becomes more challenging. In an effort to address this issue, this project seeks to enhance the support for performance data analysis in various formats commonly used by software developers. Specifically, we aim to enable the export of performance data to formats such as Firefox's Gecko profile format and Chrome's trace event format, making it easier for developers to analyze and optimize their code for different platforms and environments. By doing so, we hope to improve the overall performance and user experience of software applications.
This project addresses critical gaps in Gemini API integration across leading agent frameworks (LangChain, LlamaIndex, CrewAI, Composio), where multimodal capabilities and function calling remain underdeveloped or inconsistent. By implementing standardized components for multimodal processing, function calling, and performance optimization, the project will democratize access to Gemini's advanced capabilities for developers building sophisticated AI agents. The implementation will follow a systematic approach, beginning with a comprehensive framework audit and gap analysis, followed by development of core multimodal support, function calling capabilities, and performance optimization layers. The solution will include a unified adapter layer that standardizes Gemini API access while respecting each framework's architectural patterns. Deliverables include: (1) enhanced framework integrations with full multimodal support, (2) standardized function calling implementations, (3) performance optimization components including token management and caching systems, (4) comprehensive documentation and examples, and (5) a benchmarking suite for performance analysis. This project will establish a new standard for Gemini integration in the agent ecosystem, enabling entirely new classes of multimodal AI applications.
Like many large scale software projects, OpenMS has numerous development dependencies. Unfortunately, there is no straightforward way to quickly and easily install all of these dependencies. Some can be installed using various package managers such as apt-get, brew, or choco, while others need to be installed with a Python package manager such as conda. And finally, some dependencies need to be compiled from source code manually. The proposed solution introduces a vcpkg manifest-based dependency system integrated through CMake toolchain support. To address performance challenges, especially for large dependencies such as Qt, a binary caching mechanism will be implemented using GitHub Releases, significantly reducing build times in both CI and local development environments. Existing contrib patches will be analyzed and minimized by leveraging upstream fixes and vcpkg ports, with overlay ports introduced only where necessary. The project will deliver a fully functional vcpkg-based build system for OpenMS, including cross-platform support (Linux, macOS, Windows), CI integration with caching, and validated compatibility with core components and pyOpenMS. This will improve build reproducibility, reduce maintenance overhead, and simplify the developer onboarding process.
This project implements a debuginfod-compatible server within Debusine to provide automated debug symbol resolution for Debian developers. Currently, debugging binaries built by Debusine requires manual installation of -dbgsym packages. This project aims to eliminate this manual labor by allowing tools like gdb to fetch symbols automatically via HTTP. Based on an analysis of the elf_classify logic in elfutils, I have designed and prototyped a pipeline that identifies and extracts .debug ELF files from -dbgsym.deb packages and parses their Build-IDs. The implementation integrates this extraction into the isolated sbuild worker task. These symbols are then indexed as debian:debug-symbol artifacts and served via a custom Django view that supports the buildid/<id>/debuginfo and executable endpoints, including HTTP Range requests for partial content. Key Deliverables: 1) An isolated extraction pipeline using pyelftools within the sbuild task. 2) A Django-based artifact storage and indexing model (debian:debug-symbol). 3) debuginfod-compliant HTTP endpoints (/debuginfo and /executable) with support for mandatory headers and 206 Partial Content. 4) Documentation and integration tests for gdb symbol resolution.
<p>This project aims to migrate the AnkiDroid App to Scoped Storage. It will follow Google's recommended approach. This will involve migrating user data from Legacy Directories to those accessible by Scoped Storage. AnkiDroid's users' collections will be migrated to App-Specific Directories. Media will be stored in their respective Scoped Storage collections. Two migration mechanisms will be developed:</p> <ol> <li>For targetSdk <= 29: Using WRITE_EXTERNAL_STORAGE permission</li> <li>For targetSdk >= 30: Using permission granted by user via System File Picker</li> </ol> <p>This will ensure the data of users who update at any time will be migrated.</p> <p>Moreover, this project aims to support all AnkiDroid features under Scoped Storage. It will ensure support for Import, Sync, AnkiDroidAPI client apps, opting for external storage & preserving data post-uninstallation. Scoped Storage inevitably forced some changes in app behavior like the need for migration itself & user data being deleted upon uninstallation. This project will enable a smooth transition by providing a short introduction to these changes.</p>
GitHub issue: Opencv #27206, Opencv_contrib #3921 Fork with WIP: https://github.com/MykhailoTrushch/opencv_contrib As part of GSOC 2025 idea 11, implement algorithms for enhancement of technical quality of images. Based on the conversation in opencv-gsoc-202X mailing list, the main prioritized algorithms are: Smarter white balance algorithms Color corrections vignetting correction, chromatic aberration correction Exposure, contrast, temperature correction and enhancement in color images In my proposal, I outline some possible algorithms that would in the beginning be implemented for opencv_contrib and could be migrated to opencv, mostly in the photo module. In particular, in order of approximate importance: Auto white balance: implement FFCC Chromatic aberration correction: implement algorithm of Chang et al. Denoising: implement a CNN-based method as a module like dnn_superres Exposure correction: implement (Adaptive, Weighted) Gamma Correction Superresolution: check if any additional newer models for superresolution could be added If I am accepted as a contributor in GSOC, I expect to pursue 2-3 of these topics in-depth to fit in the timeframe of the medium-sized project (~175 hours). Also, the choice of algorithms is preliminary and might change after additional research and feedback.
<p>Layers are one of the core concepts of digital painting. They allow artists to control different parts of their artwork at once, for instance, color, lighting, lineart, as well as texture. A key feature of them is their ability to be resized, composited, renamed, grouped or deleted independently of the rest of the document.</p> <p>Patterns and textures are also essential components of an artist’s toolbox, allowing them to represent the intricacies of a physical material. They come in two forms: bitmap textures, which are images contained in e.g. PNG or OpenEXR files, or procedural textures, which are generated on the fly using their mathematical representation.</p> <p>KDE’s Krita painting suite supports using patterns and textures through two types of layers, File or Fill Layers. However, neither of them let artists create dynamically generated content: File Layers are inherently static, and Fill Layers support only color fills (like Paint Layers) or basic pattern rendering.</p> <p>The goal of this project is to let artists create dynamic content through a new, scriptable Fill Layer. To this effect, I propose to integrate Disney Animation’s SeExpr expression language into Krita.</p>
<p>This project will add the capacity for Perl 6 to produce and execute self-contained binaries on Windows, Linux, and MacOS. I will start with an executable binary for a basic Hello World program, and incrementally add support for linking to shared system and user libraries. Time permitting, I will work with my mentors to enable support and/or work arounds to enable linking to C and other languages.</p> <p>My approach will be similar to how the .NET Core creates self-contained and framework dependent deployment binaries. I have chosen this as a model as it has proven capable of running on Linux, Windows, and MacOS systems. While my work may focus initially on either Windows and the Portable Executable (PE) or Linux and Executable and Linkable Format (ELF), this approach will hopefully ensure a path forward that will eventually be capable of producing executable binaries on all popular modern operating systems.</p> <p>The basic method which the .NET Core uses to create executable binaries is by creating a manifest of information in the operating system dependent executable binary format which is linked to .NET’s runtime library, and handed to a .NET “main” function which executes the user program.</p>
Hyperledger AnonCreds v2 takes the privacy-preserving features of AnonCreds v1 Verifiable Credentials to a new level. AnonCreds v2 adds support for newer, mature cryptosuites (including BBS+ Signatures), and for a number of important Zero Knowledge Proofs (ZKP) that enable an even better balance between verifiability and privacy. AnonCreds v2 also adds a crucial new, highly-scaled approach to ZKP-based credential revocation – a crucial element of almost all verifiable credential ecosystems. Called ALLOSAUR, this new scheme allows a single revocation registry to be created by an verifiable credential issuer that scales to support millions of credentials in a fast, low-data manner. Instead of sharing millions of credential revocation statuses (revoked or not), the scheme relies on the transfer of just a handful of integers between participants, enabling secure revocation without a verifiable credential holder from having to share a correlatable identifer for themself to the verifier. ALLOSAUR requires the creation of a new component in the verifiable credential ecosystem, the revocation manager, which is the goal of this Hyperledger Mentorship – to implement a scalable ALLOSAUR revocation manager. The implementation will at least be partially in Rust, with flexibility on the choice of languages/frameworks for the web service.
"NucleusRV Core: NucleusRV is the RISC-V based Core that currently supports I, M and C extensions. It is used along with the SoC-Now SoC Generator that accepts parameters and generates an entire SoC comprising of a Core with selective extensions and other configuration, devices which are selected via parameters and a Bus Interconnect that is used as the communication medium between the Core and the Devices, which is also selected by means of parameters. Adding the support of Single Precision Floating Point (F) extension in NucleusRV Core would enable RISC-V to reach even more use-cases on the deeply embedded side. This way the SoC-Now Generator’s scope will also expand so that now the parameter to include the F extension in the Core will become available. Henceforth increasing the value of the Generator and the Core standalone itself. The SoC-Now generator furthermore uses two Frameworks Caravan and Jigsaw, for connecting Buses and Devices respectively in any CHISEL Design/IP. Single Precision Floating Point (F): RISC-V ISA contains an extension for single precision floating point instructions, which means that all arithmetic and logic operations can be executed with floating point (single precision) values."
The Hyperledger Greenhouse, powered by the Hyperledger Foundation, provides several Business Blockchain Frameworks & Tools, some of which compose the state of the art private blockchains. In particular, Hyperledger Fabric is amongst the most famous permissioned blockchains; Hyperledger Indy tackles the first big initiative to promote decentralized identity support; Hyperledger Caliper is a comprehensive blockchain-testing framework; Hyperledger Quilt enables a specific type of blockchain interoperability - enables payments across any payment network — fiat or crypto - using the Interledger protocol. Cactus is a blockchain integration tool designed to allow users to securely integrate different blockchains, promoting blockchain interoperability. This way, Hyperledger Cactus aims to provide Decentralized, Secure, and Adaptable Integration between Blockchain Networks. Hyperledger Cactus is currently undergoing a major refactoring effort to enable the desired to-be architecture which will enable plug-in based collaborative development to increase the breadth of use cases & Ledgers supported. To fully explore Cactus’ capabilities, and to promote the project’s adoption, one needs several business logic plugins that realize cross-blockchain use cases (similarly to fabric-samples). Many are proposed on the whitepaper, but few are implemented.
<p>The current implementation of libsecret's file backend uses an encryption key derived from the user's login password. Security wise this not an ideal situation. Because, the entire security of the file backend relies on the user's login password (single point of failure). This situation can be improved if the keys are protected/generated by hardware. A Trusted Platform Module (TPM) is a cryptographic hardware security module (a microcontroller) that's present on modern consumer notebooks. The proposed work involves extending current libsecret file backend design to work with a TPM.</p> <p>References:</p> <p>Daiki Ueno (n.d.). libsecret: extend file backend to use TPM2 derived encryption keys. Retrieved from <a href="https://gitlab.gnome.org/Teams/Engagement/gsoc-2021/-/issues/13" target="_blank">https://gitlab.gnome.org/Teams/Engagement/gsoc-2021/-/issues/13</a></p> <p>Dhanuka Warusadura (2021). GSoC 21: Contributing to Gnome libsecret. Retrieved from <a href="https://dnuka.github.io/gsoc21-internship.html" target="_blank">https://dnuka.github.io/gsoc21-internship.html</a></p>
<p>Spinnacker being an open source, multi-cloud continuous delivery platform for releasing software changes with high velocity and confidence, I would love to come on board and support this project with the knowledge I have previously gained and am continuously gaining from Cloud Devops Engineer scholarship sponsored by Udacity and Bertelsmann.</p> <p>Previous research makes me understand that Spinnacker is supported by almost all cloud providers in the world, ranging from AWS, Google Cloud Platform, Kurbenetes, Oracle Cloud Infrastructure, Microsoft Azure, App Engine and Cloud Foundry, this will give me a great learning experience from my mentors during this learning season, because I am currently much conversant with Amazon Web Services, but not much conversant with the other cloud providers, this brings a two way learning environment, because as I share the information on AWS, I will as well gain knowledge about the other cloud providers.</p> <p>This project idea will aim at;</p> <p>1) Ensuring continuous delivery and continuous deployments.</p> <p>2) Bringing up automated releases.</p> <p>3) Undertake deployments, across multiple, cloud providers.</p> <p>4) Master the best built-in deployments practices from spinnacker.</p>
OmniFold produces per-event weights that cannot be reused without the original analysis environment. The original OmniFold paper deposited input datasets on Zenodo but not the learned weights, iteration metadata, or normalization contract, meaning independent reproduction requires rebuilding the full training setup from scratch. This project defines a publication standard to close that gap. The solution is a versioned metadata schema (YAML), a Parquet-based storage format for per-event weights, and a Python API for loading, validating, and applying published weights to compute observables. The package supports nominal weights, iteration metadata, and one uncertainty family as the required deliverable, with HEPData integration and extended systematics support as stretch goals. Deliverables: (1) formal schema specification with required and optional fields, (2) reader/writer package implementing the Parquet-based format, (3) validation tools covering schema compliance, normalization checks, and alignment integrity, (4) end-to-end reference example demonstrating export, reload, and observable reproduction, and (5) documentation and tutorial workflow. A working prototype with 17 passing tests is available at https://github.com/aashirvad08/omnifold-gsoc-eval.
Establish a lightweight, scalable design system that brings visual consistency, reusable components, and clear UX guidance across the full scope of KubeStellar. The system will support multiple user-facing surfaces, including websites, software interfaces, and CLI-based tools. This mentorship will serve as the foundational design phase, setting the stage for a future front-end development and implementation effort planned for later this year. Special emphasis will be placed on the documentation site and contributor-facing tooling to ensure immediate impact and long-term scalability. Expected Outcome: The mentorship will deliver a scalable yet lightweight design system tailored to KubeStellar's needs. It will include a component inventory, reusable UI patterns, a full CSS specification, and visual guidelines to ensure consistency and usability across the project's five active areas. While this phase focuses on foundational design work, it will directly support a future implementation phase—enabling contributors to efficiently apply the system to KubeStellar's interfaces, including UI, Docs, and CLI-based tooling. Special emphasis will be placed on ensuring the documentation site benefits immediately from this structure.
Cacti enables two blockchain or DLT networks to transfer digital assets between each other using different mechanisms and modules, inherited from the older Cactus and Weaver projects. The Node Server acts as a container for business logic to orchestrate (or trigger) transactions across multiple networks toward achieving some desired simultaneous state change in those networks. The Relay acts as a gateway, or an ingress/egress appliance, for a given network to send communication to, and receive communication from, another network. Using the Relay or the Node Server or both, one can effect a digital asset transfer from one network to another, sample protocols for which have already been implemented in Cacti with samples for demonstration. Parallelly, there is an ongoing effort to standardize blockchain/DLT interoperation protocols through consultation and brainstorming among experts within the field under the IETF's aegis. The goal of this project is to implement the more current SATP draft specification in Cacti, in the process augmenting the Cacti Relay to be a gateway that provides a reference or template for any other standardized implementation. Using other Cacti modules and sample apps, secure transfers of digital assets using SATP must also be demonstrated. If time permits, performance measurements may also be conducted to benchmark the protocol, and specifically the Relay.
<p>After a busy couple of days at the Bristol Hackathon, the developers behind ghcide and haskell-ide-engine merged efforts resulting in an exciting new, unified language server. Building upon ghcide's snappy shake based build system and with the extensible plugin support from haskell-ide-engine, it aims to be the de-facto language server for newcomers to Haskell. It is still new and there is plenty of work to be done throughout the ecosystem to get it ready for users:</p> <h3>Implicit cradle configuration</h3> <p>Improve how hie-bios implicitly detects and sets up cradles (sessions) without the need for a hie.yaml file</p> <h3>Update haskell-lsp with new LSP features</h3> <p>The LSP specification moves quickly, and the latest version 3.15 has lots of new features that many language servers, not just Haskell ones, would love to take support of in haskell-lsp.</p> <h3>Get haskell-language-server ready</h3> <p>Now that the ghcide base and plugin architecture is mostly in place, plugins and tests need to be moved over. Continuous integration and distribution also need to be set up.</p>
With WASI-NN plugins, WasmEdge is well-suited for running AI applications. However, AI applications are more than just the model. The application must pre-process data (such as images, audio and video) into TFLite / PyTorch formats, and convert the inference results back into application data in post-processing. Here are some examples: * The [mediapipe-rs](https://github.com/WasmEdge/mediapipe-rs) project provides a Rust SDK to build applications for the mediapipe AI models. * The [llama2.c](https://github.com/karpathy/llama2.c) application is [compiled to Wasm and runs in WasmEdge](https://medium.com/@michaelyuan_88928/running-llama2-c-in-wasmedge-15291795c470) to generate text using the [llama2](https://ai.meta.com/llama/) models. In this project, we would like to build a Rust SDK to support applications on the [YOLO models](https://pjreddie.com/darknet/yolo/). - Expected Outcome: - A Rust SDK that implements the pre-processing and post-processing functions required for the YOLO models. Those functions are implemented in OpenCV and Python in the official YOLO release. - Both image and video inputs should be supported. - Examples and documentation should be provided. - Recommended Skills: - OpenCV - Rust - Tensorflow / Pytorch - WebAssembly
MLIR already makes allocation and deallocation structure explicit after bufferization and the ownership-based deallocation pipeline, but it still lacks an upstream static memory planner that can analyze buffer lifetimes and safely reuse memory for well-structured workloads. This is especially valuable for structured ML, HPC, and accelerator-oriented compilation flows where dynamic allocation is expensive or undesirable. I propose to build this in two incremental steps. First, I will implement an analysis pass that identifies eligible memref.alloc / memref.dealloc patterns, performs alias-aware lifetime analysis, computes planning metadata such as size and alignment, and reports reusable candidates and skip reasons. Second, I will build a conservative rewrite pass that rewrites eligible dynamic allocations into memref.subview-based slices of one or more statically allocated arena memrefs for legality-gated v1 cases. The main deliverables are: an upstream analysis pass for static memory planning, a conservative v1 rewrite pass for same-block structured cases, memory-space-aware planning support, strong lit/FileCheck coverage, documentation of supported and unsupported cases, and an incremental PR series that is realistic to review and land upstream.
Mifos Mobile is an android application designed for client use, which facilitates user authentication, account information viewing and editing, as well as internal transactions and repayments. In my proposal I've mentioned 4 additions to the current Mifos Mobile application. 1. Replacing the current API layer from self-service Fineract APIs to Open Banking APIs 2. Providing the user 24/7 customer chat support using RocketChat 3. Integrating external payment system, Mojaloop via the Payment Hub. 4. Covering all the screens with UI tests using Espresso. The proposed enhancements to Mifos Mobile application are expected to have a significant positive impact on the user experience. By replacing the existing API layer with Open Banking APIs, clients will be able to enjoy seamless and more secure transactions. The provision of round-the-clock customer chat support through RocketChat will ensure that users receive prompt assistance whenever they require it. Integration of Mojaloop through the Payment Hub will enhance the application's payment capabilities, and it's reach. Lastly, the coverage of all screens with UI tests using Espresso will improve the overall reliability and robustness of the application, leading to increased user satisfaction.
<p>Casbin is an authorization library that extends its features to implement Access Control Lists, Role-Based Access Control, and Attribute-Based Access Control models in various programming languages to its clients. Casbin's Core Engine is written in GoLang. Casbin-CPP has obvious benefits of speed and efficiency compared to its implementation in other languages and thus, benchmarking is vital for the project to stand out from the rest. Python is the most versatile as well as the most used programming language and has huge community support. Casbin-CPP has the potential to support new PyCasbin to compound the benefits of both languages through language bindings and extension libraries. Currently, the project uses Microsoft Unit Testing Framework for C++ for testing and Microsoft’s Azure DevOps pipelines for CI. CTest is truly cross-platform and can be configured using GitHub Actions for consistent and better CI.</p> <p>Project Ideas are as follows:</p> <ul> <li>Modernizing the project with C++17 standard and Google’s benchmarking tool</li> <li>Implement Python bindings for Casbin-CPP using pybind11 library</li> <li>Implement testing based on CTest and set up workflows for Continuous Integration through GitHub Actions</li> </ul>
The goal of the project is to develop reusable building blocks for visual exploration of Internet data. The building blocks will be developed in the ObservableHQ platform, which uses the popular visualization library D3.js. The building blocks will be open-source code, published as templates in the ObservableHQ platform. Any user would be able to fork/copy a template and plug their own data, and/or modify it according to their needs. Since the code will be in D3.js, the building blocks can be re-usable by any javascript component, not only in ObservableHQ. The targeted users mainly are Internet researchers and network. There exist various types of Internet data, mainly, tabular data (e.g., ASN or latency value), timeseries (e.g., AS hegemony per day), graphs (e.g., routing graph), paths (e.g., traceroutes, BGP paths). We will create at least one building block that can visualize each type of data. Different types of data need different types of visualizations. We will consider a range of visualizations, such as, sankey diagrams (very useful to visualize relations, paths, etc. in Internet data), graphs, geo-maps, distribution plots (e.g., histograms, violin plots), dendrograms, heatmaps.