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.
PyMC uses PyTensor as its computational backend, which allows efficient optimisation, rewrites and evaluation of mathematical operations. Using a recently introduced framework (CoLa- Compositional Linear Algebra), we identify a lot of algebraic simplifications and implement them as graph rewrites. As a result, we would be speeding up multiple model families in PyMC, such as Time Series, State-Space models and Gaussian Processes. The goal is to simplify efforts in implementations while achieving a high degree of computational efficiency
The goal of this project is to enhance the user experience of gccrs by enabling it to emit error codes similar to rustc. This will help bridge the gap between the two test suites and eventually enable the rustc testsuite to run on gccrs. The project involves implementing necessary changes in gccrs to emit rustc error codes throughout its frontend code. Additionally, it entails expanding the code responsible for error emission to incorporate greater functionality. Furthermore, a comprehensive comparison between the rustc and gccrs test suites will be conducted to improve stability. The ultimate outcome will be an improved user experience for gccrs users, with an increased number of error emissions in various contexts and more informative hints on code resolution. By bringing gccrs closer to parity with rustc, this project aims to enhance its accessibility for users and developers alike.
<p>In the current Tasking Manager process of Organised Editing Guidelines, some necessary tasks are executed manually, such as adding a project to Organized Editing Guidelines activities page including all its information like Title, contact, start and end date, etc. Some of this information is present in the Tasking Manager and the process of reporting data back to OpenStreetMap should be automatically done. This would make this activity less susceptible to errors and also save important time to the executors of this activity.</p>
<p>This project aims to improve backend test coverage to 100%, and then migrate the backend codebase to be simultaneously compatible with both Python 2 and Python 3, while putting measures in place (like lint checks) to ensure that the backend code always remains compatible with both python 2 and python 3, regardless of subsequent developer changes. The reason these two projects are linked is because one prerequisite for a safe migration is to have full test coverage, so it's important to make sure that the backend coverage is 100% before migrating.The project would then make sure that all libraries Oppia uses are compatible with python 3. This project would also standardize all scripts in the codebase to be written in Python (currently, there is a mixture of bash and Python being used). The project would end with creating a small list of remaining steps that need to be taken for a final migration to python 3 (once a solution is found for the GAE dependency issues).</p>
Demucs v4 is a state-of-the-art open-source music source separation model developed by Antoine Défossez. While it provides exceptional quality in separating audio into stems, it is currently implemented in PyTorch and therefore cannot be used directly in C++ applications or run efficiently on hardware accelerators through ONNX Runtime. This project aims to bridge that gap. Exporting the model to ONNX will allow Mixxx to integrate stem separation directly into its platform, opening up use cases like live stem manipulation, AI-assisted mixing, and educational visualization tools. Moreover, embedding the model in a minimal C++ command-line application will serve as a reference for further integration into audio applications.
Current methods in the DeepChem library struggle to understand complex polymers, limiting their application in drug delivery and materials science. This project proposes a solution: two new representation methods for these molecules. One utilizes a detailed graph structure, capturing the intricate connections within the polymer, while the other leverages a special text format (BigSMILES) for efficient storage and retrieval. By implementing these methods, DeepChem will be significantly better equipped to handle these repetitive and complex molecules. To achieve this, the project will deliver a comprehensive toolkit: new graph-based and BigSMILES featurizers for polymer data, code for data loaders and integration with DeepChem's MoleculeNet framework, trained and evaluated GCN and MAT models utilizing the new representations, and finally, tutorials, documentation, and a public dataset of polymers represented using the new methods – all to empower the scientific community for further research in this field. The proposer has experience in relevant areas like machine learning and working with polymers.
Fabric Private Chaincode (FPC) leverages modern Confidential Computing technology, such as Intel SGX, to enhance the protection of chaincode and their data while executed at the endorsing peers. Client applications interact with their private chaincode via the FPC Client SDK, which is responsible to encrypt and authenticate the invocation arguments before being sent to the endorsing peers. Currently chaincodes can be developed in C++ or Golang. The Hyperledger Labs CC-Tools library offers several features that facilitate the journey of learning, development and deployment of chaincode for Hyperledger Fabric in Golang. The goal of this mentorship project is the design and the integration of FPC as a destination for the code developed using CC-Tools. This also includes the creation of appropriate samples and documentation. The project requires a solid understanding of theory and practice of software development using Golang, distributed systems, and security. During the project you will get hands-on experience with the development of Hyperledger chaincode, the deployment of Fabric networks, the transaction lifecycle, and Confidential Computing technology. - Deep dive into Hyperledger Fabric, in particular, Fabric Private Chaincode using Confidential Computing, and the Hyperledger Lab CC-Tools - Experience an active open-source community - Mastering open-source workflow - Enhance your designing and implementing skills, testing, documentation, and project management
<p>ListenBrainz currently only displays the list of listens imported into a user's profile and the basic stats about the artists that a user has listened to. There isn't much a user can do with the recordings/listens imported into their profile. Love, hate and delete are the basic features that can be provided to the users. Love/hate feature will help in perceiving the user's taste in music and hence refine the recommendations that are generated for them. Keeping in mind the decision to migrate to Timescale DB and upon a discussion on IRC <a href=""https://chatlogs.metabrainz.org/brainzbot/metabrainz/2020-03-16/?msg=4550029&page=1"" target="_blank">here</a> it was decided to club the delete a listen feature into the love/hate a recording project. My proposal for this project aims to</p> <ul> <li>Add the 'love/hate a recording' feature</li> <li>Add the 'delete a listen' feature</li> <li>Adding the UI components for the above features and revamping the 'My Listens' page.</li> </ul>
<p>This project is sort of a hybrid project and it consists of implementation of atleast two out of three IETF RFCs/Drafts. The three features in question are "<a href="https://tools.ietf.org/html/draft-yeung-g-ikev2-13" title="Group Key Managment using IKEv2" target="_blank"><strong>Group Key Managment using IKEv2</strong></a>", "<a href="https://tools.ietf.org/html/rfc5685" title="Redirection Mechanism for IKEv2" target="_blank"><strong>Redirection Mechanism for IKEv2</strong></a>" and "<a href="https://tools.ietf.org/html/rfc5723" title="IKEv2 Session Resumption" target="_blank"><strong>IKEv2 Session Resumption</strong></a>". The "<em>Redirection Mechanism for IKEv2</em>" will be implemented before the first evaluation period, and after that it will be dynamically decided (with the libreswan mentors) whether to continue with implementing "<em>Group Key Managment using IKEv2</em>" or "<em>IKEv2 Session Resumption</em>". The reasons for that approach are described in project proposal.</p> <p>"<em>Redirection Mechanism for IKEv2</em>" and "<em>IKEv2 Session Resumption</em>" are features that will improve the performance of VPN servers, especially the ones that serve a lot of VPN clients. "<em>Group Key Managment using IKEv2</em>" will enable key exchanging for secure Multicast communication.</p>
<p>Theleague is Oauth2.0 client library allows integration with any OAuth provider that conforms to the OAuth 2.0 standard, theleague provide a GenericProvider that may be used to connect to any service provider that uses Bearer token. Apart from this many providers provide additional functionality so thephpleague can be extended and wrapped for additional behavior. The objective of this project will be to integrate Theleague into Social API project and add new implementers to Social Auth and Social Post.</p>
Currently, p5.js has a frustrating limitation for 3D artists: it flattens every imported model into a single shape that can only hold one texture. If you export a complex character from Blender or Maya with different materials for things like skin, clothing, and eyes, p5.js silently discards that information during the import process. This leaves creators with a flat, grey model instead of the detailed, textured work they actually designed. This project fixes the problem at its core by updating the library to recognize and render multi-material models automatically.
Volcano provides rich scheduling capabilities for AI workloads in the field of single cluster. In large model training scenarios, a single cluster cannot meet the computing power requirements of jobs, more and more users hope to submit jobs uniformly on multiple clusters for large model training, volcano needs to provide various scheduling capabilities, such as job management, gang scheduling, queue management, etc., and select the appropriate cluster for jobs to cope with the requirements of large model training. Expected Outcome: - Implement a basic multi-clusters scheduling framework integrated with multi-clusters scheduler like [Karmada](https://github.com/karmada-io/karmada) or other multi-cluster orchestration. - Implement gang scheduling, fair scheduling in multi-cluster. - Implement queue management in multi-cluster.
WasmEdge's JIT mode attempts to compile the entire module before execution, which also includes compiling unused functions in the specific workload. To reduce compilation time and improve performance, we aim to enable compilation on a per-function basis, focusing only on those functions actually used in the workload. - Expected Outcome: - A series of test cases that verify the behavior and demonstrate the difference between entire module compilation and per-function basis compilation. - A series of PRs that implement the per-function compilation behavior. - An option to control the behavior between entire module and per-function compilation. - A document explaining how the new approach works and how to use it.
<p>Kubescape today has no declarative, in-cluster mechanism for posture/compliance exceptions — they only come from JSON files or the ARMO cloud API, which blocks GitOps-native workflows and air-gapped clusters. A design for a `SecurityException` / `ClusterSecurityException` CRD (group `kubescape.io/v1`) already exists and covers both vulnerability and posture exceptions in a single resource with OpenVEX-compatible fields, label/namespace/image selectors, CEL validation, and Kubernetes Events for observability. The kubevuln (vulnerability) side is being implemented by the maintainers; this project focuses on the kubescape (posture) side, the operator rescan integration, and surfacing exceptions in the Kubescape Headlamp plugin so users can view and manage them from the UI.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>New `CRDExceptionsGetter` implementing `IExceptionsGetter` in kubescape, wrapping the existing getter and merging CRD posture entries (`SecurityException → armotypes.PostureExceptionPolicy`).</li><li> Match-field conversion: `resources`, `objectSelector`, and `namespaceSelector` mapped to `PortalDesignator` attributes; cloud-vs-CRD precedence per the design (cloud wins on overlap).</li><li>expiresAt` evaluated at scan time; scan-time Kubernetes Events emitted on matched SecurityException resources.</li><li> Operator `SecurityExceptionWatchHandler` watching both kinds with a debounced `CooldownQueue`, dispatching rescans on changes.</li><li>CRD manifests with CEL validation rules merged into the Helm chart.</li><li>Headlamp plugin additions: list/view `SecurityException` and `ClusterSecurityException` resources, show matched findings/events, and a guided form to create new exceptions from a failing control or CVE on a workload.</li><li>Unit + integration tests for the Go side, plugin tests for the UI, and end-to-end verification against a running cluster.</li></ul>
Integrating an upgrade agent into Litmus 3.x streamlines Chaoscenter upgrades, eliminating the need for fresh installations. This feature ensures seamless transitions between versions, especially useful when facing significant changes. Expected Outcome: 1. Seamless Upgrades: Integration of the Upgrade Agent ensures smooth transitions during Chaoscenter upgrades, removing the necessity for fresh installations. 2. Simplified Process: Users can upgrade from one version to another without the hassle of reinstallation, saving time and effort.
<p>During pre-dump in CRIU, the memory pages of target process are stored in pipe-pages, until the content is not flushed to disk image or page-server. Primary issue is bloat of irreclaimable memory due to pipe-pages. Pipe buffers are pinned in memory making them non swappable. Pipes have maximum size restriction, so there could be many pipes which results in memory pressure during pre-dump process. Replacing pipe-pages with userspace supplied buffer from CRIU will alleviate this memory pressure. Since, the buffer pages can be swapped out.</p> <p>Another issue is duration for which pre-dump algorithm freezes the target task. Use case like live migration expects smallest possible freezing glitch. So, objective is to reduce this freeze time during pre-dump.</p> <p>To achieve both of these objectives, we use process_vm_readv system call with a set of VMA-list gathered by freezing target task for minimal amount of time. There are challenges in handling memory areas with this approach, like race conditions resulting in false reads. Development of graceful solution for these challenges is objective of this project.</p>
<p>Currently, DepClean has a plugin that analyzes maven-based java projects, but we can't use it in Gradle-based java projects. The main aim of this project is to implement a DepClean Gradle plugin like DepClean maven plugin that will analyze Gradle-based java projects too. Also, the existing maven plugin may misbehave in a multi-module project analysis as it analyzes only one module at a time. So, this project also aims to make the plugin able to analyze multi-module projects such that a combined analysis will be carried out on all the modules.</p>
<p>Libreswan implements IPsec protocol, which uses IKEv2 for authentication and key establishment. IKEv2 uses the classical Diffie-Hellman key exchange methods which will soon become insecure and should be replaced with Quantum Computer (QC) resistant ones. Since most of QC-resistant key exchange methods require transfer of large public keys, the fragmentation of the messages is needed. Current IKE fragmentation cannot be used in the initial exchange and instead the IP fragmentation will take place. However, the use of the IP fragmentation has significant drawbacks, for instance some network devices do not allow IP fragments to pass through and hence IKE communication is blocked.</p> <p>Intermediate Exchange is a solution to transfer large amounts of data in IKEv2. A series of these exchanges may take place after the IKE_SA_INIT phase and enable message fragmentation via IKE Fragmentation mechanism. This allows the transfer of large keys without causing IP fragmentation. Implementing Intermediate Exchange for libreswan is the next important step in improving the long-term security of IKEv2 and IPsec such that the protocols will also remain secure against attacks by quantum computers.</p>
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.
Casbin is extended to multiple languages and frameworks including the Casbin for Node.js. To improve the user experience for the project one of the factors has to be the performance for which benchmarks may seem necessary to focus on improvement. Another factor, in this case, can be to stay up-to-date and provide the same features and functionalities as the other Casbin libraries, e.g. Casbin’s Core Engine written in Golang. One more factor to consider can be accessibility over multiple JavaScript platforms, which is planned by our mentor Zixuan Liu. To make users utilize Casbin authorization in their work, we can make it consistent with other latest/most used technologies out there, so it becomes easier for users to utilize it. WatcherEx implementation for keeping Casbin enforcer instances synced. Policy storage adapter using Cassandra DB.
<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>
Libvirt has a tool called lcitool which is used for managing the CI need for libvirt and related projects. Improvements will be made to the system toward extending the container functionality to build a container locally, and execute workloads in the container. This will give libvirt developers and maintainers the ability to debug in a project specific manner among other use cases. The goal of the project is to use podman-py, a python binding for the RESTful API of podman services , to implement this feature.
OpenROAD-MCP's adoption is limited by manual setup and the lack of production-grade deployment and validation workflows. This project delivers a complete Docker deployment story with GHCR publishing, cross-platform validation across Ubuntu, macOS, and WSL2, and a six-layer testing infrastructure covering integration tests against real ORFS flows, performance benchmarking, load testing, and memory profiling thus moving the project toward a reliable v1.0 release.
With sandboxed packaging, Linux distributions appear which do not use classic RPM or DEB packages any more, like the all-Snap Ubuntu Core. As a result CUPS will not work with classic PPD/filter-based printer drivers any more but requires all drivers being provided as Printer Applications. The student's task is to add this functionality to the Printer Application framework and create an easy way for users to install proprietary printer drivers into that chroot-equipped Printer Application. IPP Fax out is a feature which is currently missing in Linux unlike Print and Scan. The student's task here is to make this functionality easily accessible for users of common desktop Linux distributions. Like printers, faxes should automatically appear on the system and get available in print dialogs and if one prints to a fax, fax-specific options should also appear in the print dialog and the user should be able to pick phone numbers also from contacts.