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.
An important part of the analysis pipeline of high energy physics experiments is the generation of expected data from first principles. For decades, sophisticated monte carlo simulations have been performed, which are computationally very expensive and therefore pose one of the major bottlenecks in data analyses at CERN experiments. In recent years there has been an effort to explore the application of novel deep learning techniques to speed up the simulation by means of generative models. With the rise of Noisy Intermediate scale Quantum Computing (NISQ), the question comes up, if quantum machine learning can enhance existing methods. In this project we therefore explore the applicability of quantum machine learning to event simulation by means of a quantum Generative Adversarial Network.
This project is centered around enhancing the experience of playing through explorations -- Oppia's lessons, which are the primary means of learning on the platform -- and aims to provide learners with positive reinforcement as they progress through one. This will be achieved by placing messages at the checkpoints of an exploration, which are meant to display to the learner their progress and to cheer them on ahead, and by congratulating the learner when they successfully complete an exploration, followed by providing them with further learning recommendations.
<p>Adding a graphical interface for game library management, where games are displayed with cover art thumbnails, with options for grouping and filtering by publisher, engine, and other fields.</p>
<p>MetaCall Core is an open-source software that brings the polyglot programming experience to Developers. With MetaCall, developers can embed different programming languages through an easy-to-use high-level API. Jupyter Notebook is an interactive environment that allows scientists, researchers, developers and engineers to perform analysis, scientific computing, code prototyping and more. These notebooks provide a feature-rich interface where they can capitalize on visualizations, figures, plots and user-interface elements to prototype the code they are writing and working on.</p> <p>This project aims to create a kernel where the MetaCall Core can be loaded and launched through a Jupyter Notebook interface. With this Notebook, the users can try out writing and embedding code in different programming languages. It would also make it possible to use the MetaCall API and achieve the goal of bringing a unified interface for developers to try out and leverage MetaCall. The Kernel would allow developers to load the MetaCall API to execute code in different programming languages by mixing code amongst each other.</p>
<p>STL containers such as vectors/maps/sets/etc are not thread-safe. One cannot safely add or remove elements from one of these containers in one thread, whilst iterating or adding/removing in another thread without potentially catastrophic consequences (usually segmentation faults leading to eventual program failure). Currently, HPX, as The C++ Standard Library for Parallelism and Concurrency, does not have much concurrent data structure support yet. A number of libraries implementing thread-safe (sometimes lock-free) containers already exist that can be used for ideas and where code uses a boost compatible license can be integrated into HPX. In particular, LibCDS, a C++ library of Concurrent Data Structures, will be my interest as it has implemented a series of thread-safe containers using pthread. I plan to integrate LibCDS into HPX by adding hpx light-weight threading support for LibCDS. I will provide well-written unit tests and documentation on each step of my implementation.</p>
<p>There are many alternatives for L1-regularized generalized linear models in R, but none that utilizes the efficient SAGA algorithm despite its excellent convergence properties and track record of compelling empirical results. A successful implementation of the SAGA algorithm does, however, exist in <strong>scikit-learn</strong>: an actively maintained and well-documented Python module. The goal of this project is to port that implementation to R as a package targeted for submission to the Comprehensive R Archive Network (CRAN).The end result will be an easy-to-use and blazingly fast algorithm for L1-regularized models, which will come as a wanted addition to the toolkit of R users interested in big data modelling.</p>
<p>I intend to create a new CPDB backend for printing to a (PDF) file and fix the bugs in the CUPS backend.</p> <p>I also have to develop a new GTK3 Adaptor backend to add support of Common Print dialog to the gtk3 dialog, this ensures that GTK3 dialog shows the print queues received from the common print dialog and thus, the options corresponding to each printer will be independent of desktop environment.</p>
<p>The site at <a href="http://apps.loklak.org" target="_blank">http://apps.loklak.org</a> presently showcases various apps which are build with the loklak api. The aim of this project is to enhance the site and convert it into a proper app site like any other mobile app store with proper store listing of each apps, so that users are able to know how to use each app and deploy them.This project also aims at developing more loklak apps and adding them to the site.</p>
<p>TRONCO is an R package that implements state-of-the-art algorithms for the inference of cancer progressions with the ultimate goal of understanding the evolutionary trajectories driving tumor evolution. In such a multidisciplinary domain, where computer scientists actively cooperate with biologists, being capable of visually understanding the data is crucial to both parties. cyTRON is a Cytoscape app that was designed for this purpose, i.e., mapping the features provided by the TRONCO R package to a user-friendly and accessible interface.</p>
<p>Book-a-Nook is an online platform where a user can look up for available community spaces like libraries and make reservation requests to the admin. The admin checks for the conflicts and sends the corresponding confirmations. This project aims to ease the process of confirming such requests. Another major aim is to allow admin to gain useful insights on such demands through graph visualizations and report generation. The project will also aid in notifying a requestor of his/her requests’ status and favoriting locations as well as nooks.</p>
<p>Currently <strong>pgmpy</strong> provides two sampling classes, A class of algorithms namely Forward sampling, Rejection Sampling and Likelihood weighted sampling which are specific to Bayesian Model( BayesianModel in pgmpy) and Gibbs Sampling a Markov Chain Monte Carlo Algorithm that generates samples from both Bayesian Network and Markov models. Since pgmpy is looking to support continuous random variables in coming time, we need classes of inference algorithms (sampling too) that can specifically work with these continuous random variables. This proposal deals with adding two more sampling algorithms in pgmpy, namely:</p> <ul> <li><strong>Hamiltonian/Hybrid Monte Carlo (HMC)</strong>: A Markov Chain Monte Carlo algorithm that adopts physical system dynamics rather than a probability distribution to propose future states in the Markov chain.</li> <li><strong>No U Turn Sampler (NUTS)</strong>: An extension of Hamiltonian Monte Carlo that does not require the number of steps L (a parameter that is crucial for good performance in case of HMC).</li> </ul>
<p>The project aims to provide an end to end system for Learning to Rank (Letor) functionality in Xapian, which could be included in the next stable release. This shall involve integrating work done by previous four GSoC projects, creating a stable core API, writing automated test suite, and creating practical code examples.</p>
Git's partial clone allows cloning repositories without downloading all objects (blobs, trees, ...). These objects are fetched on demand from the remote when needed. However, when a user needs metadata about these remote objects (size, type, hash, ...), Git has no efficient way of doing this without downloading all the object content. The server side support for `object-info` protocol was implemented by Calvin Wan in 2021. Eric Ju built the client-side `remote-object-info` for `cat-file --batch-command`. This project finishes Eric Ju's work on `remote-object-info` for `git cat-file --batch-command`, resolves the pending feedback from Junio Hamano and Jeff King, and extends support for `%(objecttype)`. The main technical fix is to replace the insufficient `strstr()` format validation with an `allow_list` to prevent crashes on unsupported placeholders, and extending the v2 protocol server and client to handle `%(objecttype)`. After the project, Git will have a working `remote-object-info` for `cat-file --batch-command` supporting `%(objectsize)`, and a v2 protocol extension adding `%(objecttype)` support on both server and client, with tests and documentation.
The goal of the project is to implement distributed tracing in order to trace individual calls between multiple backend components. The implementation can be broken down into the following stages: Infrastructure: Deploy an OpenTelemetry colector, and a Tempo tracing backend; Instrumentation: Instrument backend components in order to send events to the collector; Tracing: Stitch events together into traces by propagating trace context; Polishing: Iterate the generated events in order to improve the observability of the system; Documentation: Document how to deploy the required components, how to add/modify generated events, and how to visualize the data.
GNOME Gitg is a graphical user interface for Git that aims to be a small, fast, and easy-to-use tool for visualizing repository history and managing projects. It is currently built on the GTK 3 toolkit, which is expected to be deprecated in the future. This proposal focuses on migrating Gitg to GTK 4, ensuring long-term maintainability, better performance, and a more modern user experience.
This project introduces a ‘Cold Start’ Data Factory that turns zero/one-shot prompting into a full data-to-training workflow. The core contribution is a production-grade DatasetWriter pipeline that converts inference outputs into validated, reproducible annotations, supports format-aware serialization, and guarantees reliable flushing/finalization for large export jobs. The generated datasets can be exported in standard formats such as YOLO, COCO, and CVAT, with quality statistics and filtering controls for practical downstream use. Building on that, the project adds direct OTX training integration: once export is finalized, the system can automatically generate training configs, spawn OTX runs, stream logs/status, and track artifacts and run metadata. This shifts geti-instant-learn from a live-inference-only experience to a complete cold-start bootstrapping system where prompt-based “Teacher” labels are transformed into trainable “Student” datasets and model training jobs. The result is a faster and more reliable path from a few prompts to deployable edge models.
Currently there is obsolete `tests/ui/issues`directory in `rustc` test suite which was used to store regression tests in it. Now with the growth of compiler this folder is basically unmanageable, test names don't explain object of testing, and they are not sorted in any way. Nowadays new regression tests are getting into the fitting `tests/ui/`subdir, and my project proposes reorganization of `tests/ui/issues` directory by observing and sorting each test to matching directory.
My idea is as following: - Getting to know the project and the architecture - Start with cursor tool, as this one is the simplest (TDD) - Next I would like to work on the pipette-tool - Fill tool is the most complex as it requires the filling algorithm, but at this point I will be very familiar with the project and this will not be a problem.
Keploy - OSS Code Indexer for Efficient Retrieval. (Project-2) Problem solved - Current AI models struggle to generate high-quality Unit Tests for large codebases without a deep, structured understanding of the source code. Solution Plan- 1. I implemented code parsing using tree-sitter to create semantic chunks, preserving essential context. 2. Then generating embeddings for these chunks with Gemini, openAI, huggigface and store them in a Milvus vector database. 3. I'm utilizing HNSW indexing within Milvus for efficient semantic similarity search. 4. Then I have extracted code relationships (function calls, class inheritance etc.) and store them as a knowledge graph in Neo4j. 5. Embeddings are generated with Gemini :- https://huggingface.co/spaces/mteb/leaderboard 6. I have developed a dynamic indexing mechanism (using file watching/Git hooks, potentially enhanced by Difftastic) to keep both Milvus and Neo4j synchronized with code changes. 7. Then I build a hybrid retrieval system querying both Milvus (for semantic relevance) and Neo4j (for structural context). 8. Then I integrated this combined context into Keploy's existing Unit Test Generation (UTG) workflow, feeding it to the Gemini API for test creation. 9. Then I need further suggestion to implement an LLM-as-a-judge component to evaluate the generated tests. Deliverables:- A robust GraphRAG system integrated into Keploy. This includes codebase indexing (vector embeddings in Milvus, structural graph in Neo4j), dynamic index updates, hybrid context retrieval, and integration with the Gemini, leading to substantially improved Unit Test Generation quality and relevance for users with large or complex codebases. Thanks. Regards Sparsh.
Over the years, a vast collection of OpenSCAD libraries has been developed by the community. These libraries provide pre-written functions and modules that can significantly accelerate the development process by offering pre-built components for common design elements, gears, fasteners, and more. However, discovering and integrating these libraries remains challenging, especially for new users. Currently, OpenSCAD lacks a dedicated library manager. This project proposes a solution by creating a simple and user-friendly OpenSCAD Library Manager. This project aims to significantly enhance the workflow for OpenSCAD users, allowing them to focus on design and innovation while leveraging the power of reusable components.
This project aims to develop a versatile mobile application tailored for efficient data management on Firebase databases. Given Firebase's popularity among small to medium-scale projects for its schemaless nature, there is a growing need for a generic mobile editor that enables seamless CRUD operations, independent of the database structure. Our project addresses this need by building a user-friendly and feature-rich mobile application that effectively empowers users to manage Firebase databases. Key Deliverables: CRUD Operations Editor: Functionality for seamless Create, Read, Update, and Delete operations on Firebase databases. Real-time Notifications: Notification system for alerting users to new or edited records, facilitating timely review and modification. User Authentication and Authorization: Secure authentication and authorization mechanisms to control access to the application. Search and Filter Functionality: Advanced search and filter options to locate records based on specific criteria easily. Export and Import Data: Ability to export data in JSON, enhancing data portability. Data Visualization: Data visualization tools to provide visual insights into data transactions and analytics. Firebase Data Audit Logging System: User activity tracking features to monitor and audit interactions with Firebase data. Batch Operations Editor: Support for batch operations to perform CRUD operations on multiple records simultaneously. In Conclusion, our project aims to empower developers with robust tools for managing Firebase databases effectively.