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.
Inspektor Gadget enables users to inspect Linux containers and Kubernetes workloads, offering the powerful capability to monitor traffic for currently running applications. So far, gadgets can only passively monitor events, the ability to generate specific events would be a great addition to the existing features. For example, if users could trigger a DNS request from a specific pod or make an HTTP request to a particular endpoint, Inspektor Gadget could check if the request succeeded or not. Users would then be notified if there are errors/outages/problems in the cluster. Expected Outcome: As part of the mentorship, you will: 1. Explore the best way to implement event generation, external program vs implementing it within Inspektor Gadget. 2. Develop DNS/HTTP event generator and see how it works with gadgets. 3. Use the event generation in our integration testing.
The sbi (Simulation-Based Inference) library currently constructs neural density estimators via opaque factory functions that accept loose keyword arguments. This design leads to delayed validation errors crashing deep inside PyTorch rather than at configuration, tangles data preprocessing (Z-scoring) with model architecture, and prevents experiment configurations from being serialized, making reproducibility difficult for researchers. This project will refactor the neural network builder infrastructure into a modular, three-tier Layered API. By transitioning to strongly-typed Python dataclasses, the new API will introduce DensityEstimatorBuilder for fail-fast validation and a fully decoupled ZScoreConfig to isolate data standardization. This object-oriented approach ensures that invalid configurations are caught immediately and allows architectures to be easily inspected and saved.
<p>PyTorch-Ignite is a great library built on top of pytorch. It provides an extremely simple engine and event system to work with, which work really well in a distributed environment. It also has a set of very handy metrics which can be used right out of the box. This is why I would like to become a contributor for the PyTorch-Ignite library. I wish to work on the metrics module because I have worked in Brain-Computer Interface, Computer Vision, Augmented Reality and am familiar with a myriad of different metrics. I am also familiar with using pytorch library and have built, trained and tested many models with it, making me a suitable candidate to work on the metrics module of PyTorch-Ignite. Contributing to PyTorch-Ignite can help me learn more about using pytorch in a distributed environment, writing test cases for your code, get used to the GitHub workflow in general.</p>
This project addresses the challenge of accurately digitizing degraded 17th-century Spanish manuscripts, which suffer from irregular layouts, archaic grammar, and low scan quality. The solution integrates a hybrid OCR pipeline: a Mask R-CNN model segments text blocks into lines, a fine-tuned TrOCR transformer recognizes printed/handwritten text, and a T5 + LLM hybrid system corrects errors while preserving historical grammar. An open-source annotation tool enables historians to validate outputs and expand datasets. Deliverables include: (1) a production-ready OCR pipeline, (2) post-correction module with fallback strategies, (3) annotation tool for dataset refinement, and (4) comprehensive documentation. This tool will enable scalable, accurate digitization of cultural heritage texts.
Liquid Galaxy RPG is a multiplayer 2D fantasy action game built for the Liquid Galaxy multi-screen display system, where a continuous tile-based world spans all LG screens simultaneously. Four players join via a Flutter mobile controller app, competing in King of the Hill (2v2 PvP castle capture) or cooperating in Dragon Raid (4-player boss fight with wave-based enemies). The game is built on Phaser 3 served via Node.js WebSocket — each LG screen opens one URL in Chromium on Ubuntu 16.04 rig. A unique AI Cheerleader powered by the Gemini API runs on each player's phone, delivering private personalized motivational messages via Flutter TTS based on live game events.
<p>The idea is to add new features as well as to improve existing features in the Catrobat iOS app (Catty). The app mainly focuses on making programming easy for children and share the created program among the Catrobat community. The features to be implemented are:</p> <ul> <li>Landscape mode: At the time of creating a new project in pocket code iOS application, the application will ask the user to select the orientation of the device using a pop message similar to that of the android application. The device orientation will be change on the basis of the user's choice.</li> <li>Google Sign-In and tagging: This will allow the user to sign-in to the Catrobat community with their google account along with their Catrobat account. I will integrate this feature using the google framework <code>GoogleSignIn</code>.</li> </ul>
The goal of this project is to bring the Maglev REST API server to a production-ready v1.0 state, establishing it as a high-performance, drop-in replacement for the legacy Java-based OneBusAway API. To achieve this, I will implement all missing endpoints to ensure full API parity, eliminate N+1 database queries, introduce robust caching strategies, and build comprehensive test coverage alongside detailed deployment documentation. Furthermore, I will engineer a native Golang GTFS data pipeline—featuring a concurrent transformer and merger—directly into Maglev. This integration will enable zero-downtime hot-swapping of transit data in memory and completely remove the system's dependency on legacy Java preprocessing tools, delivering a fully optimized, tested, and documented backend for transit agencies.
The Simple Automated Badge Issuance System is designed to automate the process of issuing digital badges to users who complete the JSON Schema Tour. The utilizes Google Sheets for collecting user data and integrates with Badgr, a platform for managing digital badges. The objective is to create a lightweight, reliable, and easy-to-maintain solution that eliminates manual intervention while ensuring scalability. The project involves developing a script that interacts with Google Sheets to fetch user completion data, communicates with the Badgr API to issue badges, and incorporates proper error handling and logging mechanisms. Cloudflare Workers or an alternative hosting solution will be explored to ensure efficient and execution of the automation process. The final deliverable will include an open-source on GitHub, complete with clear documentation to enable others to use and adapt the system
The proposal describes an initiative to create a public dataset using publically available Common Vulnerabilities and Exposures (CVE) information. The major purpose is to compile complete data points from multiple sources, add to the dataset, and make it publicly available. The proposal identifies obstacles in correlating commit IDs to CVEs and proposes using timing analysis, NLP approaches, and real-time monitoring to address these issues. The project is separated into two stages: collecting data for existing commits and CVEs and making the system real-time. The implementation strategy involves data collection, correlation algorithm creation, integration of NLP techniques and offline LLM models, and real-time system installation. The deliverables include a comprehensive CVE dataset, correlation techniques, NLP integration, and a real-time monitoring system.
This project solves the problem of inefficient on-chain trading, where current systems depend on fixed prices, off-chain matching, or complex order books that do not scale well. As the number of orders grows, matching becomes slow, costly, and less transparent. To solve this, I will build Windmill, a fully on-chain trading system where orders are not fixed but change with time as price curves. Buy prices go down, sell prices go up, and trades happen automatically when they meet. No off-chain engine, no oracle, and no central control is needed. Everything is deterministic and runs directly on the blockchain. The deliverables include smart contracts for order creation, matching, and settlement, a keeper system to trigger matches, a frontend interface for users to place and track orders, and a subgraph for indexing and analytics. The final system will be scalable and completely decentralized.
The Dart and Flutter IntelliJ plugins rely on persistent WebSocket connections to communicate with the Dart VM Service and the Dart Tooling Daemon. The current implementation uses the Weberknecht WebSocket library, which does not properly handle WebSocket ping/pong control frames. In environments with antivirus software idle connections may be terminated, causing debugging sessions and tooling communication to disconnect unexpectedly. This project proposes migrating the WebSocket transport used by the Java VM service client to the modern WebSocket implementation available in the Java standard library. The migration will update the connection and message transport logic while preserving the existing VM service protocol. The deliverables include the new transport implementation, integration into both the Dart and Flutter IntelliJ plugins, removal of Weberknecht dependencies, and validation across common development workflows.
This project develops a pip-installable Python library that bridges SymPy's symbolic mathematics capabilities with HPX's high-performance parallel computing framework. SymPy-HPX automatically generates optimized C++ code from symbolic mathematical expressions, compiles it with HPX integration, and provides a seamless Python interface. The library supports multi-dimensional arrays, stencil operations, and multiple equation systems, making it particularly powerful for scientific computing applications. Key features include automatic code generation with HPX parallelization, efficient runtime management, support for complex numerical operations, and a user-friendly Python API. The project progressed through four major versions, each adding significant capabilities: from basic expression handling to advanced features like multi-dimensional arrays and persistent runtime optimization.
<p>DBpedia, a crowd- and open-sourced community project extracting the content from Wikipedia, stores this information in a huge RDF graph. DBpedia Spotlight is a tool which delivers the DBpedia resources that are being mentioned in the document.</p> <p>Using DBpedia Spotlight to extract and disambiguate Named Entities from Wikipedia articles and then applying a topic modelling algorithm (e.g. LDA) with URIs of DBpedia resources as features would result in a model, which is capable of describing the documents with the proportions of the topics covering them. But because the topics are also represented by DBpedia URIs, this approach could result in a novel RDF hierarchy and ontology with insights for further analysis of the emerged subgraphs.</p> <p>The direct implication and first application scenario for this project would be utilizing the inference engine in DBpedia Spotlight, as an additional step after the document has been annotated and predicting its topic coverage.</p>
Jaeger is a widely used distributed tracing platform. This project aims to integrate Small Language Models (SLMs) and Large Language Models (LLMs) into the Jaeger ecosystem to provide intelligent trace analysis. Key features include natural language search mapping (mapping English queries to Jaeger's internal search parameters), contextual analysis, and summarization ("Explain this Span" or "Explain this trace"). The project involves backend integration using Go and LangChainGo, and frontend integration within the Jaeger React UI. Expected Outcome: A working "Natural Language Search" input that populates the Jaeger search form, contextual "Explain" buttons for errors and spans, a robust backend implementation using langchaingo supporting local models (e.g., Ollama) via YAML config, and comprehensive documentation.
PyDataStructs is a high-performance python package for data structures and algorithms providing C++ backend via Python C-API as well as a parallel computation that provides lightning performance. a) Single package for all data structures and algorithms. b) Consistent APIs and Clean Interface. c) Supported on all three platforms - Windows, macOS, and Linux. I aim to work on the following during the project duration - 1) Increase the scope of missing data structures and algorithms 2) Adding methods to current data structures to extend their support in other research and engineering backgrounds 3) Implementing the C++ backend to provide high performance 4) Enhancing the documentation for make it more user friendly and easy to follow 5) Aggressively test the newly added as well as the existing code to achieve 100% coverage which currently is at 99%.
ROCm is one of the open source alternatives and main competitor to CUDA. Currently, Debian and its derivatives supports only the core packages of ROCm like the driver, runtime and compiler. However, there still exist some peripheral tools and high level applications cannot be simply installed by users, making it still in the early stage for the Debian ecosystem. In this proposal, we are going to build, package and upload these missing softwares into Debian repositories to provide Debian users flawless experiences. We plan to initially package some simple softwares like monitoring and documenting tools, and then high level applications like PyTorch. After familiarizing the basic packaging skills, it comes to more challenging tasks like bug fixing and providing supports for wider GPU architectures. The final deliverables will be a series of ROCm packages with the community quality assurance met.
This project proposes the development of a graphical setup configuration wizard for istSOS4, an open-source Sensor Observation Service. Currently, configuring istSOS4 for Docker deployment requires manual editing of .env files, which can be error-prone and challenging for new users. To solve this, I will build a user-friendly React-based interface with a Node.js backend that guides users through the configuration process step-by-step, validates inputs, and automatically generates a valid .env file. The final deliverables will include: . A multi-step web-based GUI wizard . Real-time validation and feedback . Support for database, API, logging, and advanced settings . Comprehensive documentation and tutorials for deployment This tool will make deploying istSOS4 faster, easier, and more accessible for both technical and non-technical users.
<p>Linear Programming (LP) based sparse learning methods, such as the Dantzig selector (for linear regression), sparse quantile regression, sparse support vector machines, have been widely used in machine learning for high dimensional data analysis. Despite of their popularity, their software implementations in R are quite limited. Our GSOC project aims to develop a new R package -- PaRametric sImplex Method for spArse Learning (PRIMAL), for the aforementioned LP-based sparse learning methods with the following two key features: 1) It provides a highly efficient optimization engine based on the parametric simplex method, which can efficiently solve large scale sparse learning problems; 2) Besides the estimation procedures, it provides additional functional modules such as data-dependent model selection and model visualization.</p>
The validation of post-software deployment, conducted in two parts: Part 1) Validation of the installation manifests will be performed against the requirements (probably defined in a machine-readable format in PDF 2.0) and the software repositories; Part 2) Validation (comparison) of actual installation vs. the expected installation through log, directory, components, configuration, and software stack. Apart from ensuring that the requirements are met, this validation helps in minimizing/eliminating any deployment errors, drives test-automation, and checks for consistency to achieve efficient automation. Have a comprehensive understanding of the CNTT community, especially Reference Implementation and Reference Compliance Hands-on opportunity for software tool development, testing and verification Have a comprehensive understanding of software deployment tools (e.g. Airship) and related hardware provision interface, e.g. IPMI, Redfish
<p>For running its simulations TARDIS needs atomic data, such as atomic masses, ionization energies, levels and transitions. This data is available from a number of known sources. In order for TARDIS to be able to use the data, it should be downloaded, stored in a database, and converted to the HDF5 format. This task is currently done by the <code>tardisatomic</code> package; however, this package has some underlying issues. It has no clear workflow and the existing database structure is difficult to modify and maintain. These problems complicate adding and processing data from new sources.</p> <p>If my project is accepted, I will implement a new package named <code>carsus</code> (the name suggested by the collaboration) that will be deprived of the issues inherent in <code>tardisatomic</code>. The new package will have clear workflow, sound database structure and flexible input/output modules.</p>
<p>Cricket's GUI interface is currently implemented using Tkinter, which has a lot of limitations. The main goal is the complete port of Cricket to use Toga as the framework for GUI interface. The base logic is mostly complete, so firstly I will plan how to adapt the actual architecture of the view to use Toga widgets. If I find one widget that Cricket uses but isn't implemented on Toga, I will develop a contribution to this specific widget. This way the application will not lose the basics layout. So, the proposal will not only focus on the port of Tkinter to Toga, but on mapping the necessary widgets for a real application using Toga framework. In addition of the advantages of using Toga instead of Tkinter as I highlighted, this is a opportunity to improve error handling and make better use of features that Toga has but Tkinter does not. It will be the first BeeWare project that “eats it is own dogwood".</p>
This project will build friendly automation tooling to support community translation of the p5.js reference documentation (including p5.js core and p5.sound). The p5.js reference (API documentation) is authored in English via JSDoc comments in the source code, and the website currently offers documentation in five languages (English plus Spanish, Simplified Chinese, Korean, and Hindi) . As p5.js evolves, keeping these translations up-to-date is challenging. The goal is to create GitHub Actions and workflows that do not automate translation itself (which requires human nuance) but instead assist volunteer translators. These tools will automatically track changes in the English “source” docs, flag or open tasks for updates in other languages, suggest new translation needs (for newly added APIs), and streamline communication with translation contributors.
<p>ArviZ is a Python package for exploratory analysis of Bayesian models, intending to provide backend-agnostic tools for diagnostics and visualizations of Bayesian inference in Python. Generally, Bayesian inference generates numerous datasets that represent different aspects of the model. To simplify the handling, referencing, and serialization of data generated during Bayesian analysis, ArviZ uses a couple of data structures: <em>xarray.Dataset</em>, <em>arviz.InferenceData</em> and <em>netCDF</em>.</p> <p>InferenceData objects are central to ArviZ and most ArviZ functions take InferenceData as input. However, its functionality is still quite limited. The main aim of the project is to extend some methods from <em>xarray.Dataset</em> and to create specific InferenceData methods. Special attention would be given to test and document these new functionalities with examples.</p>
NeoRoo currently talks to DHIS2 through raw HTTP calls with no offline support, so if a nurse loses connectivity while entering baby data, that data is just gone. I'm proposing to integrate the d2 Android SDK as the primary sync engine and build a Flutter abstraction layer on top of it that works across both Android and iOS. The main deliverables are: a Pigeon-based platform bridge to d2 (Android) and DHIS2 REST API (iOS), an offline-first sync queue using Drift/SQLite with automatic retry, a server-wins conflict resolution system with a review log, real-time sync status indicators in the UI, background sync with battery optimization, push notifications for server-side changes, and a testing + monitoring toolkit. By the end, healthcare workers should be able to use NeoRoo reliably regardless of connectivity.