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.
Ankidroid currently lack convenient access to key study management features directly from their device's home screen. This inefficiency hampers user engagement and productivity. As improvements, I plan to address these challenges by implementing widgets for Ankidroid, focusing on three key areas: Deck Analysis, Card Analysis, and Cards Due. These widgets will provide users with quick access to vital study metrics and functionalities, improving their study management experience. The solution involves designing intuitive and visually appealing widgets consistent with Ankidroid's UI/UX guidelines and integrating them seamlessly into the app.
The OpenHistoricalMap project aims to give a temporal aspect to mapped information, adding the possibility to see maps during specific points in time. To do that, features can be provided a start date, an end date and the historical source where the data comes from. For the source, in ID, the javascript OpenStreetMap editor, there is a “Sources” field for every feature, but the field is simply a plain text field. To provide a more structured way of providing sources, that field should be updated or replaced in a way that helps users format their citations. The goal of this project is to implement a WYSIWYG interface for the sources field in the ID editor to provide a better way to register sources, alongside new validations to support the correct usage of this new interface.
Providing performant HPX functionality written in C++ with Rust APIs to facilitate safety as well as ease of learning HPX. Designing and implementing Rust bindings for HPX, exposing all or parts of the HPX functionality with a Rust API. Implementing rust's ffi along with libraries like cxx.rs, bindgen to intrope hpx functions to rust.
The project aims to enhance VLC by introducing support for WebAssembly (Wasm) plugins, paving the way for a potential replacement of the current Lua scripting functionality in the future. This endeavour involves the development of a Wasm Plugin Manager within VLC, allowing for the utilisation of plugins written in various languages that support Wasm compilation. By introducing this feature, VLC users will have the flexibility to create plugins in their preferred programming languages, streamlining the plugin development process and expanding VLC's capabilities. While the Lua scripting system will remain in place for now, this project lays the groundwork for a potential transition to Wasm-based plugins in the future, offering users even more options for customization and extension of VLC's functionality.
Monumento App Summary: Monumento, an integrated social app for sharing landmarks, visiting places, and visualizing their 3D models right from a mobile device, aims to enhance user experiences through the following key features: Desktop and Web Apps: Develop a cross-platform desktop app using Flutter. Create a web version for users to access accounts, view landmarks, and engage with the community. Ensure responsive designs and consistent interactions across devices. Social and Community Features: Implement Firebase Authentication for secure user sign-up and login. Use Firestore for real-time storage of user-generated content (posts, images, etc.). Enable user interactions such as likes, comments, and profile management. Utilize Firebase Cloud Functions for real-time notifications. 3D Visualization: Integrate 3D models of landmarks. Convert models to GLTF format for efficient loading. Augmented Reality (AR) mode allows users to see 3D models superimposed on the real world. Interactive exploration with zoom and rotation. Deployment and Scalability: Package Monumento into Docker containers for consistency. Set up CI/CD pipelines for automated deployment. Choose deployment platforms (Heroku, Firebase Hosting, or GCP) and monitor performance post-launch.
Discovering new phenomena, like the Higgs boson, involves the identification of rare signals that could shed light into unanswered questions about our universe. On the other hand, at the Large Hadron Collider (LHC), large amounts of data are generated from particle collisions. This project aims to develop a Quantum Lie-Equivariant Graph Neural Network (QLie-EGNN), a quantum model that not only is data efficient, but also has symmetry-preserving properties from any arbitrary Lie algebra that can be learned directly from the data.
This proposal seeks to enhance the d-SEAMS core engine's usability and extend its capabilities through two main initiatives: simplifying the installation process by building and distributing Python bindings via PyPI, and incorporating advanced visualization and machine learning functionalities. By leveraging tools such as PyVista for visualization and scikit-learn for data analysis, the project aims to make d-SEAMS more accessible and powerful for researchers in molecular simulations, contributing to advances in genetic disease research and understanding of ice nucleation. This comprehensive upgrade will provide an easily installable, more versatile tool for the scientific community, enhancing research workflows and outcomes.
Build the traffic rule distribution process of dubbo-b8s, implement traffic rule push in various environments such as k8s, universal, mesh, enhance the traffic management of dubbo-go, adapt dubbo-go to the Service Mesh environment, write dubbo-go-xDS-client-sdk to implement dubbo-go's support for the xDS protocol, and write related demos.
NeuralPDE.jl is a high performance Julia package to solve differential equations using neural networks. This proposal aims to improve the sampling framework in the package to include user generated symbolic loss functions, add Neural Tangent Kernel adaptive loss function for improved training and add Deep-Ritz method to solve high dimensional second order PDEs to the package. The proposal also aims to expand the codebase of the LuxNeuralOperators.jl to include high performance codes for Fourier Neural Operators, Markov Neural Operators, DeepONets and other operator learning schemes and perform benchmark tests to the package.
This proposal aims to enhance the ScrapeConfig CRD to achieve stability and usability. Currently in alpha, the CRD lacks the originally intended 1:1 relationship with Prometheus configurations. The project outlines a roadmap to address these issues, focusing on adding necessary fields, extending support for service discoveries, and implementing thorough testing. The plan includes a strategy for graduating the CRD to beta and eventually stable versions, following Kubernetes API versioning guidelines. Deliverables: Updated ScrapeConfig CRD with added fields to support service discoveries and other configuration options. Thorough test coverage for the added fields and overall functionality. Graduation of the ScrapeConfig CRD to beta stage, with documentation outlining the upgrade process. Enhanced documentation providing up-to-date information on the CRD and migration guides for users upgrading if necessary.
The objective of the "Physics-based Sonar Simulation for Underwater Robotics" project is twofold: firstly, to transition to ROS2 and integrate with the latest Gazebo simulation environment, and secondly, to substantially enhance the plugin's functionality. A key goal is to diversify the range of sonar models within the simulation, thereby significantly extending its relevance and efficacy across a variety of underwater conditions and operational scenarios. This strategic expansion aims to provide a more versatile and comprehensive tool for simulating dynamic underwater environments, facilitating advanced research and development in autonomous underwater navigation and obstacle avoidance. Deliverables: 1. A fully migrated and functional physics-based sonar simulation plugin within the ROS 2 framework and the LTS version of the new Gazebo. 2. Enhanced performance and capabilities of the plugin to support higher refresh rates. 3. A comprehensive suite of tests and validations conducted in simulated environments, ensuring reliability before real-world deployments. 4. Extended functionality through the inclusion of additional sonar types, catering to a broader spectrum of research and operational needs.
Project Deliverables • Implement a Project edit button, file and project rename functionality, fix edit project popup , allow editing list of notebooks , and add images to each type of notebook. • Implement support for Jupyter notebooks. Users should be able to upload, view, and edit Jupyter notebooks on the platform. Use Jupyter Lite, or nbviewer, or nbconvert to render notebooks in HTML format. • Allow users to fork existing projects. Forking should create a new project that is linked to the original, allowing users to experiment with changes without affecting the original project. • Improve the project creation and editing process. Add validations for project names to ensure uniqueness. Enhance the project edit functionality to prefill forms with existing information and update project names and routes when edited. • Implement a user permission system to differentiate between project members and followers. Users can join projects as members or follow them with the project owner's permission. • Set up a continuous integration system for automated Docker container generation. • Migrate the project's blob storage to Jetstream. Ensure a seamless transition with minimal downtime and data loss. Set up automated, regular database backups. • Bug Fixes: Address existing bugs in the platform, such as issues with the registration code, disappearing navbar account menu, and join button behavior, to improve user experience and platform stability. • Implement an organization system where users can create and manage organizations. Organizations can have multiple projects and users associated with them. Define roles such as admin, members, and followers within organizations to manage permissions and access levels. • Implement comments in projects and logs along with a reply-to field, vote field to up/down voting, and a ‘flag’ field for flagging.
MetaCall has multiple embedded runtimes and aims for cross-platform versatility. However, managing dependencies across different runtimes poses a significant challenge. Leveraging Guix, MetaCall achieved self-contained builds for Linux. This project focuses on enhancing support for MacOS, aiming to streamline the build process and improving support for various loaders built into MetaCall. By implementing CI/CD pipelines for OS X and refining the installation scripts, the project aims to offer stable binary distributions of MetaCall for various OS X versions, ensuring seamless functionality across diverse environments.
Modernization of the FURY code base to improve readability, maintainability and performance. This project aims to modernize the FURY code base by implementing keyword-only arguments to improve code clarity and explicit parameter passing. In addition, the integration of lazy loading functionality will optimize performance by loading resources only when they are needed. Finally, active participation in code refactoring efforts will improve the structure and maintainability of the FURY code base. The project will result in a modernized code base, comprehensive unit testing, updated Sphinx documentation and public presentations illustrating the improvements and benefits. Ultimately, the aim is to significantly improve the FURY code base for future developers and users.
Bring the most recent classical and deep learning methods for categorical encoding to Julia to better support the presence of categorical variables in machine learning problems. This will at least include target encoding, entity embedding, potentially other methods and improvements on existing ones. The methods will be implemented in pure Julia and easy-to-use interfaces for them will be exposed to the community.
Benchmarking sampler implementations for Bayesian inference is hard — the algorithms are inherently stochastic, and often produce only Monte Carlo samples of some distribution of interest. As a result, Bayesian inference lags other areas of machine learning in the availability of common benchmarks. To help solve this, the Stan team put together posteriordb, described as: "a set of posteriors, i.e. Bayesian statistical models and data sets, reference implementations in probabilistic programming languages, and reference posterior inferences." (posteriordb Github readme). This proposal would add Turing implementations for most of these models, facilitating easier sampler benchmarking in Turing. This database would also serve as a set of examples of Turing best practices. The project will result in a database of 120+ varied Bayesian models written in Turing, representing translations of a database of corresponding Stan models. Regarding deliverables, the proposal pdf contains a detailed and complete schedule, directly blocking out time for 130+ of the posteriors, with some additional stretch goals included. As a summary, (1) Initial weeks are spent getting familiar with Turing best practices while building out 50+ of the simplest models (mostly, variants of Bayesian regression). (2) Weeks leading up to the midterm assessment are blocked off for GLMMs and Bayesian ODEs. (3) Weeks following the midterm assessment are dedicated to two types of discrete models — first, models with a discrete structure amenable to simply summing out the discrete components (e.g. mixture models). Second, I'll implement HMMs, which require some specific algorithms to match the Stan posteriors. (4) Chip away at remaining models that don't neatly fit into a specific category, for example, neural networks, splines, and gaussian processes. If a week ends with models incomplete, I'll move on to the next week, ensuring a varied selection of models make it into the database.
Currently, the codebase lacks comprehensive unit testing coverage for all critical components, and the existing unit tests do not provide adequate coverage. The primary objective of this project is to augment unit test coverage for essential files, aiming to achieve a coverage range of 90% to 95%. Subsequently, these unit tests will be seamlessly integrated into the existing GitHub continuous integration and continuous deployment (CI/CD) pipeline. The CI pipeline is presently triggered on each pull request to the 'develop' branch. However, merging is contingent upon the successful execution of these tests, which can be manually triggered by either the maintainers or the developers locally. The overarching goal is to establish an automated testing framework, ensuring that no code is merged unless it passes all requisite tests, with the exception of documentation or non-code-related pull requests.
Virtio is an open standard designed to enhance I/O performance between virtual machines (VMs) and host systems in virtualized environments. VirtioFS is an extension of the Virtio standard specifically crafted for file system sharing between VMs and the host. This is particularly beneficial in scenarios where seamless access to shared files and data between VMs and the host is essential. VirtioFS has been widely adopted in virtualization technologies such as QEMU and Kata Container. Apache OpenDAL is a data access layer that allows users to easily and efficiently retrieve data from various storage services in a unified manner. In this project, our goal is to reference virtiofsd (a standard vhost-user backend, a pure Rust implementation of VirtioFS based on the local file system) and implement VirtioFS based on OpenDAL. Through this project, VMs can access numerous data services through the file system interface with the assistance of the OpenDAL service daemon deployed on the host, all without their awareness. It ensures the efficiency of file system reading and writing in VMs through VirtioFS support. This storage-system-as-a-service approach conceals the details of the distributed storage system from VMs. This ensures the security of storage services, as VMs do not need to be aware of the information, configuration and permission credentials of the accessed storage service. Additionally, it enables the utilization of a new backend storage system without reconfiguring all VMs.
The project **Micro Front-ends Proof of Concept for Fineract 1.x & Mifos X** aims to propose and design architecture for the micro-frontend approach for our angular web app. We must identify which existing and new screens should be implemented as separate microservices UIs. Also, I will be working on enhancing the look and feel of the app.
Currently the ShapeTool that is implemented in Native Pocket Paint is missing in the Flutter version of Pocket Paint. My proposal would be to implement the ShapeTool in Flutter and also fully write a extendable testing system for the tool. Depending on the time constraints I would also extended the shape inventory to include more sophisticated shapes.
extending test coverage to root filesystem selection and documenting config(8). rump servers will be used to write test in ATF of NetBSD. This project shall improve on stability of NetBSD.
This proposal aims to create a web-based Integrated Development Environment (IDE) specifically for writing and executing SPARQL queries within Tracker. This user-friendly interface will empower developers by allowing them to compose and edit multiline SPARQL queries directly in a code editor, eliminating the need for the traditional terminal approach. Once a query is written, it can be effortlessly executed via the HTTP SPARQL endpoint, and the results will be presented in a visually appealing format, enhancing readability and user experience. By lowering the barrier to entry for newcomers, boosting developer productivity with visual editing, and fostering collaboration through easier query sharing, this web IDE promises to significantly improve the experience for those using libtracker-sparql to interact with RDF databases.
This project aims to improve how Asyncapi objects are visualized in AsyncAPI by introducing a new preview feature. By combining Markdown and MermaidJS Class Diagrams, and flowcharts, users can seamlessly integrate with AsyncAPI schema and Avro (.avsc) files, creating dynamic and interactive representations of object structures. The project focuses on building clear class diagrams, and flowcharts with MermaidJS, connecting entities with channels, schemas, and operations, and providing additional info for a visually intuitive understanding of message payloads in AsyncAPI. I have planned to take the following action points to accomplish this goal: 1. Set up the project by installing all necessary dependencies and organizing the structure. 2. Develop a new Preview Panel resembling the HTML rendering panel in asyncapi-react standalone. 3. Integrate a components folder to facilitate markdown generation for all asyncapi objects, including mermaid diagrams. 4. Implement mermaid support for diagrams and utilize EJS as a template. 5. Introduce a tool for converting HTML to Markdown, such as turndown, to enable export functionality. Additionally, I plan to incorporate flowcharts, Class Diagrams, and display relationships among AsyncAPI specifications objects. A fully-fledged Preview Panel of Markdown for VS-Code will become the outcome of this project.
Protein-ligand interactions play a crucial role in various biological processes, and accurately predicting protein binding sites, where ligand molecules interact, is essential for drug discovery and understanding protein function. Current approaches integrated in DeepChem, such as the use of (geometric) deep learning or molecules fingerprints, mainly focus on predicting protein-ligand binding affinity, and require complex data and/or are computationally expensive. This project focuses integrating ESM-2 (a state-of-the-art protein language model from Hugging Face) with DeepChem, for the purpose of protein binding site prediction. This integration will enable DeepChem library to utilize powerful protein representations learned by ESM-2. A detailed tutorial will be written to provide not only a workflow for streamlined binding site prediction, but a guide that empowers researchers to use protein language models for further tasks within DeepChem. This project broadens DeepChem's toolbox, making it more versatile for the drug discovery community, and ultimately accelerating progress in this area. The main deliverables are: A function for feature extraction using the pre-trained ESM-2 model. Integration of extracted features with binding site information. DeepChem model architecture for protein binding site prediction. Reports for model performance and evaluation metrics. Tutorial documenting the complete workflow, including code, data pre-processing steps, model training details, and visualizations of predicted binding sites (if possible). If time allows, an additional tutorial showcasing the application of ESM-2 protein representations for a different task (e.g., generating peptide binders for target proteins), or implementation of a LoRA wrapper for the ESM-2 model, along with a corresponding tutorial explaining its functionality will be developed. Alternatively, both will be documented as open issues on the DeepChem GitHub repository for future development.