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.
pwndbg currently has support for debugging the jemalloc and glibc allocators. There are many programs out there that use different allocators, so extending support is important. I will implement support for musl's allocator: mallocng. This will require gaining a precise understanding of the used data-structures and algorithms. It will involve carefully reading the source (https://git.musl-libc.org/cgit/musl/tree/src/malloc/mallocng). In the end pwndbg will have additional commands for visualizing the data-structures used by mallocng, analogous to the heap, bins, arena, mp, vis etc. commands used for glibc malloc.
This project implements a domain system for formal power series in SymPy, enhancing the ring_series module with PowerSeriesRing (Domain), PowerSeriesPolyRing, and PowerSeriesElement classes. It enables efficient series expansions, domain integration, and arithmetic over diverse coefficient domains (e.g., QQ, RR). Key deliverables include a robust API, Taylor expansions (e.g., sin, exp), and documentation. Extended goals involve optimizing ring_series and fixing bugs for better performance.
Beehive aims to be a scalable web application that enables users to capture, upload, and manage images seamlessly while ensuring automation, security, and efficiency. The project will feature a robust UI, a secure backend with role-based access, and cloud deployment with CI/CD integration for smooth updates. Final Deliverables: - Fully functional web application - Secure authentication and role-based access - Automated CI/CD & cloud deployment - Testing & security validation
As developers, we always favor tools that enhance and streamline the programming process, including plugins that provide error reporting and insights to improve the code quality. Kotlin developers using Gradle rely on tools like Detekt and Ktlint to enforce code quality. While Detekt and Ktlint offer reporting in various formats like (HTML, SARIF), their current integration with IDEs can be fragmented, requiring developers to switch contexts and manually review findings, which disrupts the coding workflow and slows down their development process. This project aims to implement a unified and actionable code quality reporting system through the integration of the recently introduced Gradle new Problems API. This API provides structured and rich information about the problems happening during a build. The information provided can be used by different interfaces such as Gradle’s console output, build scans, or IDEs to communicate any issues. With this API integration and structured format of the generated report, developers can experience faster issue identification, streamline debugging, and have improved code maintainability. This project will provide value to the Kotlin development community by upgrading the quality of their error reporting.
This project aims to build an AI-driven behavioural monitoring system to detect mental health, suicide, and substance use crises in real time using social media data. It will analyse engagement patterns and crisis-related language using NLP (TextBlob, BERT, LDA) and geotag posts for mapping regional distress trends. Deliverables include a sentiment and risk classification pipeline, geospatial heatmaps, and an interactive dashboard to help public health teams proactively identify and respond to emerging crises.
This project introduces an AI-powered agent that automates the transformation of API responses into structured UI schemas and functional UI components across various frontend frameworks. Using Multiple LLM-Based Agents, the system eliminates the need for manual UI creation by intelligently analysing API responses and generating corresponding UI structures. Additionally, it enables dynamic modification of UI components based on user prompts, allowing for customisation in design, layout, and behavior. By seamlessly integrating these capabilities into a unified workflow, the project streamlines frontend development, reducing manual effort and accelerating the UI generation process with a single-click solution. The project also aims to create a simple one-click API Request to Tool Generation pipeline that can enable external AI agents to interact with APIs without any manual coding Deliverables: • A Modular AI Agent Creation & calling mechanism for apidash's future AI-based tasks • One-Click solution to generate UI components from an API Response • One-Click solution to automatically generate API Tools to be used in various Agentic Frameworks like Langchain, Autogen and so on.
Financial factor investing relies on rigorous quantitative research to explain asset returns and generate alpha. While many academic models and institutional frameworks exist, open-source tools that replicate these methods — especially in R — are few and far between. This project aims to close that gap by contributing to the ExpectedReturns package, developing clean, modular functions that implement and generalize key factor construction techniques inspired by Antti Ilmanen’s Investing Amid Low Expected Returns. The focus will be on engineering reusable code for factors like value, momentum, profitability, and investment using raw or semi-structured financial data. These will be built using lightweight, testable components supported by packages like FactorAnalytics, PerformanceAnalytics, and tinytest, while following conventions used by Chen, Zimmermann, and Kelly. Also included will be vignettes and documentation that show how to reproduce these concepts in practice — making the tools both transparent and portable. This will be a two-month project. Deliverables will include: – Core functions for factor construction and data prep – Lightweight unit tests and clean vignettes – Documentation of inputs, outputs, and assumptions – A reproducible build setup that works across systems The goal is to make these concepts accessible — not just for researchers, but for anyone trying to understand and apply factor models in real-world contexts. If successful, this project will leave behind a set of tools that are as useful to the open-source community as they are to academic replication.
The SOFIE (System for Optimized Fast Inference Code Emit) project is an initiative within the TMVA (Toolkit for Multivariate Data Analysis) framework in ROOT, which aims to enhance the efficiency and speed of inference on Machine Learning Models. SOFIE converts ML models trained in different frameworks such as ONNX, PyTorch, and Tensorflow, converting them into an Intermediate Representation (IR). This IR allows SOFIE to generate optimized C++ functions for fast and effective inference of neural networks and subsequently convert them into C++ header files, which can be used in plug-and-go style for inference. For GSoC 2025, this project aims to enhance the Keras parser to support models trained in the latest TensorFlow v2.18.0, which introduces NumPy 2.0 compatibility. As well as Integrate JAX/FLAX support, enabling SOFIE to generate C++ inference functions for models developed using JAX/FLAX
This project will implement the recent techniques from Gallagher et al. (2024) and Gallagher et al. (2025) for improved time series simulation studies covering the whole parameter space of time series models (and not just cherry-pick one or two parameter settings) and also bring modern estimates of the acf/pacf and consistency in AIC selection of ar models (which is not currently available). Specifically, the project will: - create functions for acf and pacf estimation based on a dual shrinkage approach - create functions for ar estimation based on the dual shrinkage pacf - interface the new ar estimation function with standard methods such as AIC for consistent estimation - create new graphics for displaying these estimates that make clear to the user the effect of the dual shrinkage approach (as an option) - create functions to generate ARMA parameters that satisfy a correlation constraint (high/med/low or a fixed correlation strength) - create functions to generate random ARMA parameter values that cover the whole parameter space regardless of the model order - create a wrapper for the above two functions to generate simulation datasets for researchers in one line of code All this functionality will require appropriate documentation, testing and a vignette for users.
The aim of this project is to develop a comprehensive learning resource for developers working with the Gemini Python SDK. This would consist of a range of documentation, interactive code samples and an easy to use pre-written package that demonstrate cover a range of topics which can be used to efficiently manage long content, one of the most common challenges when building with large language models. It will provide an overview of techniques such as batching, chunking and handling various media types (such as text, audio and video) in addition to highlighting best practices for techniques such as caching and error handling.
This project aims to enhance robot data collection using affordable kits and the Dora framework. It involves building a modular MuJoCo simulation for robotic arms, implementing a Dora data collection node in the LeRobot format, and generating diverse manipulation datasets. The collected data will be documented, open-sourced on HuggingFace, and supported by beginner-friendly tutorials and demos to showcase real-world applications. Deliverables include simulations, a data collection tool, a sample dataset, documentation, tutorials, and a public dataset release.
pocketpy provides a tensor library, cTensor, for users who want to integrate neural networks into their applications. cTensor implements automatic differentiation and dynamic compute graphs. It allows users to train and deploy neural networks on client-side devices like mobile phones and microcontrollers (e.g. ESP32-C3)
ClangIR is a new, MLIR-based intermediate representation of C and C++ code. It has been developed in an LLVM incubator project, but work is now underway to migrate the code from the incubator to the main LLVM repository. The goal for this project is to upstream the VectorType, ComplexType and Exception handling
AsyncAPI Conference Website is an essential part of the AsyncAPI Community, it serves as the gateway for the Conference Speakers, Participant and the community member to view the upcoming conferences and participate within it . As the conference website grows, there is a need to enhance the conference website repository in terms of reusability and maintainability for future growth. The goal of this project is to develop a comprehensive UI Kit that can enhance the existing design, and streamline the development process to simplify the creation and management of cohesive elements in the website. This UI Kit will help in preventing the process of rebuilding similar components.
This project focuses on implementing a versioning system for the DISCOVER Cookbook, enabling seamless navigation across distinct documentation editions via a dynamic, metadata-informed version-switching interface. Moreover, each version will support multiple languages, necessitating the development of both version and language switchers. Leveraging Git branches and an enhanced GitHub Actions deployment pipeline, the project will programmatically build and deploy versioned instances, ensuring persistent access to historical content alongside current revisions. The user interface will include a dynamic version-switching mechanism and a context-aware notification banner to alert users when they are viewing outdated content. This enhancement will improve the usability, maintainability, and accessibility of the Cookbook for both users and contributors, while providing maintainers with a scalable and transparent content management workflow.
This project aims to redesign the FOSSology interface with a user-centered design approach that enhances usability and accessibility. The redesign will focus on improving the navigation, making it easier for users to find what they need and complete tasks more efficiently. Enhancing visual hierarchy, and ensuring consistent formatting, we will create a more intuitive experience. A scalable, reusable design system will be developed to ensure that the platform can grow and evolve in the future. Iterative testing and user feedback will guide the design process, ensuring that the final result meets user expectations and improves their overall experience with FOSSology.
Open Climate Fix’s Quartz Solar forecasting model uses a simple rule-based "adjuster" that averages recent forecast errors to correct incoming solar forecasts. While effective in stable conditions, this method is rigid and might be suboptimal under rapid weather transitions or atypical error patterns. This project aims to compare this rule-based logic with TabPFN, a transformer model for tabular data. It seeks to evaluate whether TabPFN or its time-series variant, TabPFN-TS, can predict adjustments based on features such as time, forecast horizon, recent errors, and more. Through experiments, one key goal is also to determine whether TabPFN improves forecast skill—specifically the P50 quantile forecast—over the current approach, and whether it is efficient enough for deployment.
Lucene.NET’s current replication system lacks seamless integration with ASP.NET Core and is not modular enough for use across diverse application types like Windows services or cloud-native tools. This proposal focuses on enhancing the `Lucene.Net.Replicator` by introducing full support for ASP.NET Core Dependency Injection (DI), simplifying configuration to a one-liner, and enabling real-time replication using technologies like WebSockets or gRPC. Additionally, it aims to modularize replication components to support non-web environments and build robust unit tests and real-world examples. Deliverables will include: - DI-based configuration system for easier integration in ASP.NET Core and beyond. - Real-time replication architecture replacing polling. - Support for Windows services, CLI tools, and distributed systems. - Comprehensive testing and documentation. These changes will make Lucene.NET replication more developer-friendly, scalable, and production-ready.
The fw-fanctrl tool currently relies on calling the ectool CLI repeatedly to control and monitor fan behavior on Framework laptops. This approach introduces performance overhead due to frequent subprocess creation and text parsing. The goal of this project is to improve efficiency and maintainability by converting ectool into a shared library and integrating it directly with fw-fanctrl using Python bindings. I have already implemented a working prototype using ctypes, exposing essential EC functions as shared library calls. During GSoC, I will refine and extend this prototype and expand the shared library to support more ectool functionalities. I will also benchmark and optimize both ectool and fw-fanctrl, and contribute to building a simple cross-platform GUI. Deliverables include: • Full ectool library interface • Ectool optimizations • Python bindings and integration with fw-fanctrl • Fw-fanctrl optimizations • fw-fanctrl GUI contribution
Django’s contribution workflow has several manual and repetitive processes that create bottlenecks for maintainers and contributors. These processes, ranging from ensuring coding style adherence to checking test coverage, commit message formatting, and proper deprecation handling, are error-prone and take up valuable time. This project aims to automate these workflows, reducing manual effort, improving contributor experience, and maintaining Django’s high-quality standards.
The is a project to take maintenership of the "asyncapi/generator" repository. The focus is on developing maintainer skills by handling issue triaging, bug fixes, PR reviews, writing tests, improving documentation, helping newcomers to contribute and guiding the project's long-term growth. The mentorship provides a deep understanding of open-source maintenance, making it a valuable opportunity for career growth and industry experience.
This project builds a fully explainable NLP pipeline to identify and classify Military-Involved Conflicts (MIC) from raw text articles. Unlike pretrained models, it uses a custom heuristic approach—extracting countries, actions, dates, fatalities, and sentiment based on rule-based logic. Though this results in longer processing times, it ensures complete transparency, flexibility, and interpretability, which is critical for social science and humanitarian research. The pipeline can later be scaled using models like BERT to enhance classification while retaining its explainable foundation.
This project aims to enhance the usability, accessibility, and responsiveness of the RUXAILAB UI while modernizing its codebase by migrating from Vue 2 to Vue 3. The solution involves redesigning the entire user interface, focusing on improved navigation flows, responsive layouts, and WCAG accessibility compliance. These designs will then be implemented using Vue 3 alongside Vuetify 3 as a component framework to accelerate development. Also, the project will systematically migrate the codebase from Vue 2 to Vue 3 using a phased approach with @vue/compat, methodically updating all major packages including Vue Router, Vuetify, Vuex, and Vue-i18n. The final deliverables include a fully migrated Vue 3 codebase leveraging the Composition API for better code organization, a completely redesigned user interface with intuitive navigation, responsive layouts, WCAG-compliant accessibility features, and seamless dark mode functionality.
This project focused in converting the concept of Magic ePaper App into a feature-packed, cross-platform app for personalized ePaper display powered by NFC. Central to it is a robust image editor, developed on the basis of the pro_image_editor package, offering users simple yet effective tools for painting, text styling, and embedding emojis, as well as tuned image adjustment controls. Key achievements encompass the creation of a sophisticated image processing pipeline, complete with advanced dithering filters such as Atkinson and Floyd-Steinberg. Additionally, a dynamic color quantization system was designed, adeptly adapting to the specific palette of the chosen hardware. Importantly, support for a new range of Waveshare displays was seamlessly integrated by harnessing their native SDK; this was accomplished through a Flutter Method Channel coded in Kotlin. In addition to the fundamental editor and image pipeline, new functionality was added directly into the edit experience, such as a flexible Barcode Generator, Customizable Design Templates, and an XBM Export capability. I also established the groundwork for internationalization (i18n) and added out the CI pipelines with GitHub Actions for auto-building and running Integration tests. The project is now an agile and accessible tool that enables users to quickly create dynamic, green content for ePaper badges.