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.
<h3>Smart Tempo in MuseScore 4</h3> <h3>Adding static and dynamic tempo changes</h3> <p>The primary focus of this project is intended to improve the engraving support for static tempo markings, by allowing the user to input complex temp markings with ease. The project will also add "Relative Tempo Changes" which are another category of static tempo markings. Once these goals are achieved, and enough time is available, the project will tackle adding basic dynamic tempo changes which have been a long requested feature. Once fundamental support for dynamic tempo changes are done, tempo resets will be added to complement both the static and dynamic changes</p>
<p>This is a proposal concerning the addition of E2E encryption support for the Matrix bot in Go, go-neb. The project would touch upon other parts of the Matrix ecosystem for Go. Specifically the gomatrix library would need to be enhanced to support encryption-specific events (such as for the uploading and claiming of keys, handling of encrypted room events) and would potentially contain the bulk of the interactions with libolm, making it easier for future projects in Go to use the same functionality. Finally proper bindings for libolm need to be developed - some such projects exist but lack necessary operations for full E2E communications. The final result of this project would be go-neb working fully in encrypted rooms, as transparently as possible to its services.</p>
CXL is an interconnect which uses memory disaggregation to overcome the memory bandwidth bottleneck from most workloads. OCEAN, one such CXL emulator built on-top of QEMU, has support for modern CXL3.0 features and supports multi-host communication is one emulator which has the potential to enable CXL-based studies. The infrastructure and studies performed by OCEAN are relatively new and limited. This project seeks to mature OCEAN's infrastructure by improving documentation, improving the accessibility and ease of setting up OCEAN, and improving the capturing of HW counter metrics which will later be used to asses how CXL can be integrated and used within the memory hierarchy to enable performance gains on HPC-class workloads.
LFortran's MLIR(Multi-Level Intermediate Representation) backend executes fortran code via LLVM dialect of MLIR, but requires major refactoring with every new MLIR version. This is because it calls unstable MLIR C++ APIs directly, which gets changed with MLIR version changes. This project focuses on finding the right design to solve this problem. Multiple approaches will be studied and compared including studying projects which support MLIR to identify the most stable and maintainable architecture. The best design will then be implemented and validated. The deliverable is a redesigned MLIR backend that is stable across MLIR versions, requiring minimal refactoring for adding support for newer versions in future.
<p>The aim of this project is to improve the Rust developer experience via the Rust Language Server by introducing few notable improvements. The scope includes supporting more workspace configurations (multiple targets and active crates) as well as popularly requested IDE features, such as implementing code action mechanism on the server side, e.g. used for refactoring or running specific tests, or improving diagnostic data required for better code navigation. Providing good out-of-box IDE experience will substantially help with widespread adoption of Rust and support writing not only quality self-contained libraries, but also incentivize writing advanced end-user oriented applications.</p>
There is ongoing work to instrument the Rust standard library with safety contracts. Based on a discussion by the Formal Verification Working Group there is still a lot of work to leverage the power of separation logic in contracts, and make it compatible with existing tools that use separation logic. The nature of my contribution would be more research-oriented, since a very good understanding of the connection between separation logic, existing tools and what we can and need to support in Rust contracts is necessary. Based on this research, a successful project should deliver the appropriate code contributions to support (partially or fully) separation logic in Rust contracts, and ideally demonstrate its compatibility with existing tools by tackling selected challenges in the Verify Rust Std Lib project.
ipeCD v1 - the new version based on a plugin architecture (ref: [PipeCD plugin-arch overview blog](https://pipecd.dev/blog/2024/11/28/overview-of-the-plan-for-pluginnable-pipecd/)), has released an alpha version, and we are rapidly adding features supported in v0. We need to develop a plugin for PipeCD v1 to support [Amazon ECS](https://aws.amazon.com/ecs) deployment. - Expected Outcome: - ECS plugin for PipeCD - Possible update plugin SDK while develop the plugin - Possible update docs how to develop PipeCD plugin - Blog about how to develop a PipeCD plugin on [https://pipecd.dev/blog/](https://pipecd.dev/blog/)
<p>CGAL works on computational geometry. It has a Demo version of a package named '2D Regularized Boolean Set Operations'. With the use of generic programming and understanding of computational geometry, this project aims at adding support to existing Demo with missing features like exception handling, file handling, complement operation, full integration of Minkowski Sum with color buckets, Undo, Console, flexible viewport and solving bugs that exist in various features of the Demo like PAN along with enhancing the functionality to support operations over a larger domain of polygons and improving the UI/UX for this Demo, ultimately making this a production level publishable demo for the next CGAL release.</p>
ENIGMA currently lacks third-party integration with various digital distribution platforms such as Steam, Xbox, or Origin. First-class support for these services would make it easier for Indie developers to publish ENIGMA-created games. Developers would like for it to be easier to monetize their games and enable them to release bigger and better updates to their users. An integrated architectural layer will be created between Steamworks ENIGMA's extension APIs and Steamworks SDK. ENIGMA's Asynchronous system will be updated. Currently, ENIGMA's Networking system is not stable so Steam Networking features will be postponed for later for now I will add support to these APIs: Management, General, Overlay, Leaderboards, Achievements, Cloud, and Social.
The project deals with the integration of RISC-V Compressed Extension into the NucleusRV core. For most embedded processors, the size of programmable memory is a huge limitation. Most of the frequently used instructions can be compressed i.e. compiled into 16-bits instead of 32-bits. We can perform a better utilization of memory by adding extra hardware to handle the compressed instructions. This project aims to: * Design the compressed decoder and pre-fetch modules for NucleusRV core for Compressed Instructions support. * Verify the working of the project using RISC-V Compliance test suit * Document the complete project and guide on how to integrate the C extension support of RISC-V based cores written in SCALA.
This project aims to create an API for users that can provide the data in ROOT files directly in a “delayed” form that is supported by Dask. It will reimplement the uproot.lazy function which will now be called uproot.dask. This function will support all of the Dask backends, leveraging the dask.array, dask.dataframe and dask-awkward delayed types in Dask. Uproot is expanding to include Dask for smooth integration with other common data processing libraries. This project is a major revamp of the structure and codebase of Uproot and the changes will also include updating Uproot to use Awkward Array v2. This will result in a new major version of Uproot i.e Uproot v5.
<p>“Htsget retrieval API spec” [1] is a specification by the <a href="http://www.genomicsandhealth.org/" target="_blank">Global Alliance for Genomics and Health (GA4GH)</a> for genomics bulk data transfers. This is a Streaming API that allows users to query remote services for regions of interest of genomic data, instead of having to download gigabytes of data and filter afterwards. The results are retrieved in formats that can be consumed by widely used bioinformatics tools. The specification currently supports BAM and CRAM formats.<br> Variant Call Format (VCF) is the standard for describing genomic variation in bioinformatics. The goal of the project is to extend the specification to support the VCF format and provide an implementation.</p>
Make the developer experience for Carbon developers better by adding support for Carbon to editors and IDEs. Possible tasks include: Create an "official" VSCode extension with a mirror repo and packaging similar to the Vim repo we provide. Add syntax highlighting using a Tree-sitter grammar for Carbon. Create a language server for Carbon Deliverables • A working language server for Carbon that supports features like code completion, diagnostics, and go to definition. • A parser that can handle incomplete or erroneous input and produce a Carbon AST. • A test suite that verifies the correctness and performance of the language server. • A tree-sitter parser for Carbon that passes the explorer test suite. (Optional)
This project proposes mlr3hf, an R package for integrating Hugging Face datasets into the mlr3 ecosystem. The package will allow users to download datasets from Hugging Face, cache them locally, and convert them into mlr3 tasks efficiently. To support large datasets, the package will use Parquet + DuckDB for lazy, disk-based querying, minimizing RAM usage while preserving scalability. It will also support fallback handling for canonical formats such as CSV, JSON, and TSV, along with split-aware task creation for train/test/validation datasets. The final outcome will be a practical, memory-efficient, and CRAN-ready workflow for using Hugging Face datasets in mlr3.
Matplotlib is a popular data visualization library that is used in multiple academic and industrial projects. LaTeX is a common tool for formatting mathematical symbols in most technical plots. Matplotlib supports mathematical typesetting through the ‘mathtext’ module. This LaTeX framework enables mathematical symbols, math fonts, and font encodings to fine-tune the usability of math texts inside a data plot. This project focuses on improving mathtext by examining the known/reported issues within the existing framework, expanding support for new Math-LaTeX-based features, and incorporating robust testing to track down unobserved issues. The overarching goal of this project is to improve the functionality and usability of mathtext for a wide spectrum of use cases.
The National Ecological Observatory Network (NEON) collects and provides long-term, open-access ecological data. The NEON Data API provides access to this data. The NeonVegWrangleR helps retrieve Neon Vegetation Structure data (VST) and Airborne Observation Platform ( AOP ) data samples from The NEON Data API, cleaning it, integrating both data, and providing researchers with a format ready for ecological analyses. But currently, NeonVegWrangleR primarily supports the R language. This project aims to provide support for python by refactoring the R functions to python and improving the package by adding tests, setting up CI/CD platform, and documentation. Hence, NeonVegWrangler meets Python packaging release standards.
<p>The project tools-golang is a set of packages in Golang intended to assist the programmers of Go language to work with SPDX files. At Present, the tools-golang only handles SPDX files which are in tag-value format. It should also be capable of reading, writing and modifying SPDX files in RDF format, as an RDF format is also officially defined by the SPDX specs. Thus, the primary objective of this project is to add support for the official RDF format. Also, enabling compatibility for parsing and generation of documents under pre-2.1 versions of the SPDX specs is another aim of of this project. If time permits, support for other formats like XML, YAML and JSON can be incorporated as well.</p>
The interaction cross-section is an important quantity in high-energy physics, serving as a bridge between abstract theory and experiment. Is is also quite difficult to compute for physical processes involving many final-state particles. The SYMBA project utilizes machine learning, specifically a sequence-to-sequence (seq2seq) transformer model, to symbolically calculate a crucial component of the cross-section - the squared amplitude - from the amplitude for a given process. The goal of this project is to improve upon the current SYMBA results with a seq2seq transformer which takes advantage of the rich structure of Feynman Integrals, allowing one to directly input a Feynman Integral for a general process/theory and obtain an accurate symbolic representation of its squared amplitude.
This project involves updating cyPlot(a Cytoscape app written in JAVA) which provides the ability to plot data through GUI or CyCommands/REST. CyPlot uses plotly.js to achieve plot related functions. CyPlot also customizes plotly.js and PlotlyEditor to suit the needs of CyPlot. It currently supports plots including heatmaps, violin plots, volcano plots, dot plots, line graphs, and scatter plots. The main goals of this project include: 1. Add Histogram as an additional plot type. 2. Implement log scales for scatter plot, line plot and histogram plot. 3. Support linear regression. 4. Updated user interface (UI)
Flood is a torrent monitoring service that works with a variety of clients. The Flood-Mobile app aims to provide a user-friendly mobile interface utilizing the Flood as a backend. My primary goal would be to make the Flood-Mobile app more useful by incorporating the objectives such as RSS Feed feature in the app along with filtering content features, adding notification action support to the app, increasing test coverage of the app, setting up fastlane for easier deployments, improving the file selection architecture and other additional features like adding a quick guide for the app, improving the management of the back button, implementing archive feature in the app and implementing change language feature in the app (multi-language support).
I plan to enhance the RIoTPot by adding new emulated protocols (HTTPS, SFTP, SNMP). I also plan to increase RIoTPot's ability to evade being detected by tools like Nmap by adding high interaction support. I will implement reverse proxies in the middleware to route the requests to corresponding dockers that contains libraries used by real-life IoT devices (such as Apache httpd). The protocols with high interaction support include SSH, TELNET, HTTPS and SFTP. My timeline for these improvements is as follows: by June, I plan to add low-interaction protocols. In July, I will implement proxy routing for container traffic. From July to August, I will integrate high-interaction protocols and write documentation.
<p>Tensorflow Datasets or tfds makes the work of the user easier by transforming the raw dataset into a standard format so that it can be immediately fed into the machine learning pipeline. This library handles the downloading of data, transforming it into a standard format, as well as preparing and constructing it as a tf.data.Dataset - so that building data pipelines and dividing records into training and testing splits is straightforward. No preprocessing is necessary from the user side. Each dataset is implemented as a subclass of DatasetBuilder which handles the dataset appropriately. There are a lot of good quality research datasets for which DatasetBuilders are still needed to be implemented.<br> This proposal is based on adding more functionality to TensorFlow-Datasets library and creating DatasetBuilders for some common important research datasets.</p>
Joplin’s end-to-end encryption protects notes during sync, but not on the local device. This project adds local note encryption so users can lock sensitive notes behind a vault password while preserving compatibility with sync and existing E2EE. The implementation will use an option-gated save/load flow, on-demand decryption, protection against plaintext leaks through search and revision history, and a lock screen UI for desktop. Guaranteed deliverables are a working desktop implementation, vault password management, sync/backward-compatibility support, and tests for data-safety and conflict handling. Stretch goals include mobile support, resource encryption, and CLI/Data API integration.
OTX supports 15+ detection models but has no built-in tracking.Every real-world video application (conveyor belt counting, asset monitoring, dwell-time measurement, traffic analysis, sports analytics, etc) needs stable object tracking across frames. This project integrates Multi-Object Tracking into OTX, adding five tracker implementations (ByteTrack, SORT, DeepSORT, OC-SORT, BoT-SORT), a SAM-2-inspired memory bank for re-identification, MOT17 benchmarking, and CLI support along with documentation. The design is decoupled: a new OTXTracker base class owns all temporal state while existing OTX detection models remain untouched.