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.
GCC Rust (gccrs) is an alternative Rust compiler frontend based on GCC, aiming for full integration into the GNU toolchain. This project focuses on improving the HIR (High-Level Intermediate Representation) visitor pattern and migrating lint checks from the middle-end to HIR. These improvements will enhance gccrs's overall code quality.
This project aims to implement a Near-to-Far Field Transformation (NFFT) feature in gprMax. This will enable users to compute the far-field radiation patterns and radar crosssections(RCS) from the near-field data. It will expand gprMax’s capabilities for antenna design, scattering analysis, etc. I propose to implement the Near-to-Far Field Transformation (NFFT) module and its integration at several key points in the existing workflow: - Adding the NFFT command - Module for Field Sampling during FDTD - Post-Processing & Far-Field Calculation - Integration with the API - Validation and Testing - Documentation and Review
This project focuses on porting the PyCUDA-based FDTD method solver of gprMax to HIP API. The final target is to run gprMax on AMD ROCm GPUs. HIP Python and HIPIFY+Pybind are considered to be used to do the porting work. The final deliverables consist of the ported kernels and the adaption to the original gprMax code, the setup script, benchmarks, and documents.
A smooth and intuitive onboarding experience is essential for any app, ensuring that users understand its features while maintaining trust and engagement. This project focuses on enhancing the ListenBrainz Android onboarding flow by making it more informative, user-friendly, and privacy-conscious. Key improvements include a dedicated Listen Submission screen to give users full control over which apps contribute listens, clear permission rationales, and fallback mechanisms for denied permissions. Additionally, a revamped sign-in screen will provide better navigation, including a bug report option for easy issue submission. These improvements are crucial for user transparency and trust. By introducing a Listen Submission screen, users can choose how and when their listening data is collected, ensuring privacy and control. Clear permission rationales and fallback handling prevent confusion and provide users with alternative ways to grant necessary permissions. The addition of update prompts and options like disabling battery optimization in settings ensures users stay updated with the latest features and optimizations effortlessly. Seamless updates and proactive issue resolution enhance the overall experience. Integrating an update prompt for Play Store and F-Droid users keeps them informed about new releases, while a "Report Bug" button on the sign-in screen streamlines feedback collection. These refinements will significantly improve user retention, ensuring ListenBrainz remains a top choice for tracking listening habits while prioritizing privacy and usability.
CrocoLakeTools is a Python package designed to convert oceanographic datasets from various formats (like netCDF and CSV) into CrocoLake’s unified Parquet-based data lake. This allows researchers to work with clean, consistent data without dealing with technical format issues. In this project, I’ll be extending CrocoLakeTools by developing new converters for the Saildrones and Oleander datasets, two widely used but structurally complex sources. The focus will be on building efficient conversion pipelines using tools like xarray and dask, while also improving testing, documentation, and overall usability. These additions will expand the tool’s dataset coverage and help researchers access and process more ocean data.
This project aims to add VMM acceleration support to QEMU on FreeBSD, bridging the gap between QEMU’s userspace emulation and FreeBSD’s kernel-based VMM hypervisor. Currently, QEMU on FreeBSD lacks hardware acceleration, forcing users to rely on slower TCG emulation or switch to bhyve. I plan to modify QEMU’s memory management to work with VMM’s kernel-allocated guest memory. Additionally, I will adapt VMM to make non-critical devices (HPET, RTC) optional, letting QEMU handle them in user space. This would enable a hybrid interrupt model (kernel vLAPIC + emulated IOAPIC). The deliverables for this project would be a working -accel=vmm backend for QEMU. I will also add some changes to VMM, allowing some of the in-kernel devices to be made optional. Finally, I will add comprehensive documentation and benchmarks for the libvmmapi interface. This will enable near-native performance for QEMU on FreeBSD, expanding virtualization options while maintaining compatibility with existing QEMU tooling.
With the increasing adoption of RISC-V as an open-source Instruction Set Architecture (ISA), there is a growing need for effective and reusable verification methodologies. While Traditional verification methodologies struggle with variability of RISC-V cores leading to extensive testbench modifications, our project resolves this by leveraging the RISC-V Formal Interface (RVFI) and PyUVM making UVM-based verification more accessible to a broader audience.
Attackers can exploit homoglyphs, or visually similar characters, to perform social engineering attacks or evade spam and plagiarism detectors. Unicode contains over 200 writing systems (scripts). Many of these scripts, such as Latin (in western Europe) and Cyrillic (in eastern Europe), contain characters that are look-alikes. This project aims to develop an AI tool to detect confusable characters and ultimately improve Unicode security mechanisms automatically.
Many DBpedia entries, especially for cities in the Southern Hemisphere like South Africa, incorrectly store geo-coordinates with positive longitude values. Wikipedia's diverse coordinate template formats often fail to parse correctly, resulting in missing geographic data. These inaccuracies can result in incorrect mapping and spatial data interpretation. This project aims to enhance DBpedia's Extraction Framework by: Refactoring GeoCoordinateParser.scala with robust input validation and hemisphere-aware sign correction. Implementing a flexible GeoCoordinateParserConfig system with regex patterns and parameter mapping. Adding unit tests and integration tests for validating geo-coordinate correctness. Extending the GeoCoordinatesMapping.scala file to parse and emit directional info. Refactoring and cleaning up legacy extraction logic to support consistent coordinate output. Deliverables: Patch to the Extraction Framework implementing these improvements. Test suite to validate parsing and extraction of directional metadata. Documentation for contributors on how to test and extend the geo-coordinate logic.
This project automates receipt processing and expense reporting using OCR capabilities of multi-modal LLMs to address the time-consuming nature of manual expense tracking. Users upload receipts into designated chat channels—each representing a specific event, time period, or trip—where the system validates the image, extracts structured data such as amount, date, and items, and categorizes expenses automatically. The processed data is stored persistently, allowing users to generate detailed spending reports in various formats (daily, weekly, monthly, yearly, or custom date ranges), filter by specific channels, or view overall spending. Additional functionalities include natural language query support, optional slash command integration to perform actions like showing receipt data. All designed to streamline financial tracking by minimizing manual input and enabling efficient, structured querying of expense data.
The project aims to design and implement an ergonomic and efficient API for accessing, manipulating, and performing operations on vector data such that implementing complex vector-based algorithms or developing tools to perform vector manipulations is efficient and ergonomic. The second aspect of the project is to enhance performance and stability by transitioning from Bezier-rs to Kurbo algorithms and data structures to perform vector operations.
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.
3DMR is a community-driven repository for 3D models and their metadata, designed to enhance 3D map rendering. It was originally developed during Google Summer of Code 2017 by Pedro Amaro, under the mentorship of the OpenStreetMap community, with Jan Marsch and Tobias Knerr serving as mentors. Since then, the project has been left largely abandoned and now runs on an outdated Django 2.0.5 codebase. This proposal aims to revive 3DMR by modernizing its foundation—upgrading the framework, adopting glTF as the standard model format, and introducing a range of improvements including robust model validation, enhanced preview functionality, and automated quality analysis feedback.
The imputeTestbench package offers an automated framework to benchmark various imputation techniques on univariate time series. It has been widely used in research for its ability to simulate missing data scenarios and evaluate multiple methods side-by-side. However, its current scope is limited to univariate data and lacks the performance and flexibility needed for more complex real-world applications. This project proposes a major upgrade to the imputeTestbench package by extending its capabilities to multivariate time series, improving its computational performance, and adding a modern, interactive user interface via Shiny. The new version will also support advanced imputation techniques, including machine learning and deep learning-based approaches, and provide options for distributed computation using tools like Apache Spark.
This project aims to complete and modernize the React-based UI of FOSSology by aligning it with the updated REST API v2 and current frontend best practices. The work includes finalizing the incomplete interface, upgrading React to 19.1.0 for improved performance and concurrency, and migrating from yarn to pnpm for faster, space-efficient development. It will also implement UX improvements from the FOSSology UX and UI redesign project and create a reusable component library with Storybook. Comprehensive documentation and deployment guidelines will be provided to ensure long-term maintainability and contributor onboarding.
This project implements comprehensive patient-facing digital health capabilities in the CARE platform by integrating Ayushman Bharat Digital Mission (ABDM) Personal Health Record (PHR) flows. While CARE currently supports provider-side health information exchange through the existing ABDM module, it lacks patient-centered features that would allow individuals to access and control their health data. My solution builds a complete set of APIs and interactive user interfaces to bridge this gap by implementing seven key components: ABHA Enrollment - Digital identity creation with multiple verification methods Profile Login - Secure multi-channel authentication and session management User Profile Management - Personal health information control and preferences Discovery and Linking - Finding and connecting fragmented health records Subscriptions & Notifications - Automated health updates and alerts Consent Management - Granular control over data sharing permissions Health Record Display - Unified view of medical history across providers The implementation seamlessly integrates with the existing ABDM module while adding complementary PHR capabilities, enabling CARE to function effectively in dual roles—as both a provider-focused clinical system and a patient-centered health record platform. Deliverables include a fully functional implementation of all ABDM PHR APIs, an intuitive and responsive patient portal interface, comprehensive transaction tracking for compliance, and thorough documentation. All components will adhere to healthcare security and privacy standards while providing a cohesive user experience. The completed project will transform healthcare delivery by eliminating information gaps between providers and empowering patients as active participants in their care journey.
The mysqltest tool is a core component of MariaDB’s testing infrastructure. Currently, it has two limitations that restrict the flexibility and expressiveness of test scripts: 1. Limited Variable Substitution: The tool only supports basic variable access patterns. 2. Lack of Expression Support: It lacks support for arithmetic, comparison, and boolean operations. This project addresses both limitations by implementing SQL-like function support and expression evaluation to the mysqltest language. It also enables users to write more concise, maintainable, and powerful test scripts while ensuring backward compatibility with existing tests.
I am Ryan, a college student finishing their last semester for a bachelors in computer science. My contribution to the multi-agent traffic optimization project would be to take the lessons I’ve learned from my previous bevy projects, and use them to update and improve rmf_site’s infrastructure over the course of several stages, and to use those improvements to add procedural generation for the tests sites that will then be used for multi-agent optimization testing. The stages for this would be as follows: 1. bevy 0.12 -> latest version of bevy + library updates.. 2. Compile time improvements 3. Debug tool improvements 4. test scenario automation through procedural generation. Update everything: The first thing to do would be to update rmf_site bevy and all other dependencies to their latest versions. I’ve done this for all my projects since bevy 0.11, and I can do it for rmf_site too. Improve Compile TImes: The next step would be improving compile times. When I tested this project on my local machine. Iterative compile times took around 50 seconds. With the appropriate restructuring of crates, slimmer crate imports, more granular feature flags, and the introduction of the mold linker, these recompile times could be cut down to around 2-7 seconds. Improve debug tools: After that, then comes adding more debug tools. We can add bevy_inspector_egui for bevy entity/component inspection, bevy_tracing for performance optimization via Tracy. Automate test scenarios: Lastly, would be adding procedural generation for test sites. First, would be adding initial tests with randomized prefab placement, then moving to procedural room layouts from tiles, then assigning different layout kinds to each of these, (storage room, office room, etc..), and then finally connecting these different layouts together into a single site.
As stated in the Mifos Forge, Users of Mifos have long had a need to have greater control and flexibility over creating loan and customer onboarding workflows that incorporate internal processes/steps as well as processes involving external systems. This project would center around creating an external integration with a workflow engine such as Flowable or jBPM using the Mifos X REST API as the glue. The auto-generated client library from the back-end enforces the contract between the workflow engine and the core banking system. The core banking and its REST API act as the glue. The result would be a UI-driven workflow engine to allow non-technical users to define these new custom workflows, where they could drag and drop the different steps of the process.
The goal of this project is to improve OpenCV’s imgcodecs module by reducing code duplication, enhancing performance, and improving format support. Deliverables: Modular and maintainable imgcodecs module. Faster, more efficient image I/O. Improved support for modern image formats and metadata. Robust and complete JPEG XL implementation with animation.
This project aims to complete the microservices infrastructure for FOSSology by continuing the work from GSoC 2021, with a goal to fully deploy FOSSology on Kubernetes. Over the past few years, multiple changes have been made to the codebase and the build system, requiring updates and integration strategies. Key deliverables include: - Reviewing and aligning the legacy GSoC Kubernetes setup with the current codebase - Completing pending work from pull request #2086 - Providing a fully working FOSSology Kubernetes deployment - Creating comprehensive documentation for Kubernetes setup - (Stretch Goals): Creating a single setup script, implementing health checks, and exposing usage/performance metrics This project ensures easier deployment, better scalability, and modern DevOps practices for FOSSology’s infrastructure.
The goal of this project is to develop an HR management module for the CARE system, streamlining employee management and automating leave and holiday tracking. The platform enables HR to efficiently manage employee records, process leave requests, securely handle document uploads, manage holidays, and allows employees to apply for leave and access their profiles and leave history.
D’s current JSON libraries (e.g., Phobos’s std.json) rely heavily on dynamic typing, which sacrifices type safety and performance—critical drawbacks for systems programming. For example, parsing JSON data into a generic JSONValue container forces developers to manually validate field types and existence at runtime, introducing overhead and error-prone code. This project addresses these limitations and enables type-safe JSON processing with constant memory by building higher-level functionalities on top of jsoniopipe, which exemplifies the language’s strengths in compile-time function evaluation(CTFE) and introspection.
Haskell language server (HLS) implements the server part of Language Server Protocol (LSP) to improve user experience of reading and writing Haskell. Signature help is a LSP language feature which shows function signatures and documentation when the cursor is inside a function application. It can also highlight part of the signature related to the current parameter the cursor is at. Users want this useful feature. This project implements signature help for HLS.