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.
This project aims to enable the seamless integration of the Silicon Compiler's hardware design tools and flows within popular development environments like Visual Studio Code (VS Code). Silicon Compiler is an open-source, modular build system that automates the translation process from hardware design source code to silicon. It essentially serves as a "make for silicon," enabling developers to efficiently compile and synthesise hardware designs into silicon implementations. By leveraging the Silicon Compiler's microservices and developing a JavaScript API, users will be able to run various hardware design tasks, such as logic synthesis, place-and-route, static timing analysis, and simulation, directly from within their familiar coding environments. This integration will streamline the design process, improve productivity, and provide a seamless experience for developers working with Verilog or related hardware description languages (HDLs) within the editor. Instead of switching between different tools and environments, they can leverage the integrated functionality directly within VS Code, streamlining their workflow and improving productivity.
The world of procedural generation in gaming, exemplified by titles like No Man's Sky and Minecraft, utilizes algorithms to create vast universes and landscapes. From textures to terrain, and even sound, these games generate content on the fly, allowing for endless exploration and variation. In projects like ENIGMA, machine learning is poised to enhance this process by crafting shaders that can be converted into dynamic textures, paving the way for even more immersive experiences. By leveraging techniques like genetic programming, developers aim to optimize the generation process, ensuring consistency and quality across diverse gaming environments.
The project would undertake the necessary code restructuring to facilitate OpenSCAD's transition to rendering with modern OpenGL. An important early step will be adding clear delineation between code paths that result in underlying calls to the two different rendering methods. This groundwork would then grow into developer-controlled flags that would enable the eventual deprecation of the legacy fixed-function calls. Part of the process will involve assessing the readability and testability of higher-level rendering classes and performing refactoring in line with guidance from other developers. Another key area of focus includes assessing and implementing any remaining workarounds needed to replicate the information exchanged between OpenCSG and the legacy rendering classes.
Some VR headsets such as Meta's Quest 2 come with a Virtual Desktop tool that lets you connect your computer to the headset and get virtual desktops. There's a client-side application (Meta Horizon Workrooms) and a desktop-side component. The desktop-side component exists for Windows and Mac, but not for Linux. That's what we want to build. The goal is to come up with a working prototype that is good enough for early adopters to play with and other developers to join the effort.
CPAchecker now supports reachability analysis, which can search for a path from the initial program location to the error location. This project is a Proof of Concept, to implement the Backward Reachability Analysis, i.e. search for a path from the error location to the initial location. The main goal of this project is to implement a control-flow automata (CFA) transformer in CPAchecker that reverses program executions by following the transitions backward, such that for any program path in the original CFA, there is a corresponding equisatisfiable path in reverse CFA. After the transformation, the existing analysis can be applied to verify the reverse CFA, thus enabling the Backward Reachability Analysis.
Pluto uses the Distributed module (part of Julia's stdlib) to create worker processes and to send Julia data structures between them. These worker processes cannot create other processes themselves, meaning that —in practice— Pluto notebooks cannot use Distributed. This project aims to solve this problem by replacing Distributed in the Pluto codebase with a new package for inter-processes communication, so that Pluto notebooks can use Distributed without any issues.
The proposal focuses on migrating the project from the use of deprecated AsyncTask to Kotlin coroutines. Coroutines are a great way of handling background operations. Since AnkiDroid is already migrating to Kotlin, I think it is time to migrate the codebase to using Coroutines as well.
<p>VLC is the most widely used media-player. It supports wide-range of media formats, both audio and video. For macOS, the UI is outdated, and needs a bit of redesign. This project aims to modernize VLC’s UI and give it a similar feel to the UI on iOS/tvOS.</p>
<p>Libreswan implements IPsec protocol, which uses IKEv2 for authentication and key establishment. IKEv2 uses the classical Diffie-Hellman key exchange methods which will soon become insecure and should be replaced with Quantum Computer (QC) resistant ones. Since most of QC-resistant key exchange methods require transfer of large public keys, the fragmentation of the messages is needed. Current IKE fragmentation cannot be used in the initial exchange and instead the IP fragmentation will take place. However, the use of the IP fragmentation has significant drawbacks, for instance some network devices do not allow IP fragments to pass through and hence IKE communication is blocked.</p> <p>Intermediate Exchange is a solution to transfer large amounts of data in IKEv2. A series of these exchanges may take place after the IKE_SA_INIT phase and enable message fragmentation via IKE Fragmentation mechanism. This allows the transfer of large keys without causing IP fragmentation. Implementing Intermediate Exchange for libreswan is the next important step in improving the long-term security of IKEv2 and IPsec such that the protocols will also remain secure against attacks by quantum computers.</p>
<p>The rise of reinforcement learning based problems or any problem which requires that an agent must interact with an environment introduces additional challenges for benchmarking. In contrast to the supervised learning setting where performance is measured by evaluating on a static test set, it is less straightforward to measure generalisation performance of these agents in the context of the interactions with the environment. Evaluating these agents involves running the associated code on a collection of unseen environments that constitutes a hidden test set for such a scenario. The goal of this project is to set up a robust pipeline for uploading prediction code in the form of Docker containers that will be evaluated on remote machines and the results will be displayed on the leaderboard.</p>
<p>This document, submitted to the GNSS-SDR open-source software defined radio project as part of the 2018 Google Summer of Code (GSoC) program, proposes an algorithmic change to an key part of the signal processing pathway utilized by the GNSS-SDR project in order to perform outdoor positioning using a software defined radio. The first section of this document describes in detail certain techniques which represent the current state of the art for GNSS positioning, along with citations and literature supporting the effectiveness of these techniques in GNSS positioning.</p>
<p>Joomla! is an Open Source CMS which allows the user to create websites with ease. It is rich in features that helps even a novice to set up a fully functional and a secure CMS.</p> <p>Joomla! 3 is the current stable version which is available to users. Joomla! 4 will be the next generation which is going to use more modern technologies.</p> <p>Joomla! has a built in Media Manager to manage media files, such that even a novice can easily upload and use them in his articles etc. In Joomla! 4, the media manager will get rewritten from scratch with a JavaScript based (Vue.js) client and a REST like API as data endpoint. Through this endpoint it is possible to make GET, POST, PUT and DELETE requests to fetch and manipulate the media files. On the server side are the requests forwarded to an adapter, which processes the data.</p> <p>The aim of this project is to add more cloud based file adapter’s through the Joomla plugin system for the media manager which allow the other developers to extend the capability of it. They can add a cloud file system to Joomla! which allows the users to interact with media files the same way as with local files.</p>
<h3>Import from Google Sheets</h3> <p>I'm Saurabh Batra, a sophomore student at IIT Guwahati, India. I've been actively contributing to Civi since October 2015 and my main point of contact and mentor has been Eileen McNaughton. The project I'm interested in developing for GSoC 2016 is <a href="https://wiki.civicrm.org/confluence/display/CRM/Google+Summer+of+Code+-+2016#GoogleSummerofCode-2016-ImportfromGoogles/sheet" target="_blank">the one Eileen proposed</a>.</p> <h5>The main objective here is to replace the data-source of the consisting import code with a generic, interface-based package (<code>ddeboer/data-import</code>) in order to:</h5> <ul> <li>Add more source formats which can be imported.</li> <li>Make the code more manageable.</li> </ul> <h5>The secondary objectives are:</h5> <ul> <li>Integrate import from Google sheets to the database.</li> <li>Provide an Angular form on top for on-the-go validation.</li> </ul>
This project aims to extend the Julia linear algebra ecosystem by developing vendor-agnostic GPU kernels in NextLA.jl for large-scale structured matrices. It focuses on tile low-rank (TLR) representations, which exploit low-rank structure to reduce computational cost and memory usage. The project will implement truncated SVD routines and core TLR arithmetic kernels, including low-rank GEMM, TRSM, and SYRK with adaptive truncation. These kernels will serve as building blocks for large distributed TLR algorithms, demonstrated through the implementation of a distributed TLR Cholesky factorization. By the end of the project, NextLA.jl will provide a portable, composable foundation for GPU-accelerated distributed linear algebra.
The more notes you accumulate, the harder it gets to keep them organised. At some point, manually tagging things or deciding which notebook something belongs to just stops happening and things pile up. What I'm building is a plugin that handles that quietly in the background. It analyses your notes, figures out which ones are about similar things, and suggests tags and notebook structures that reflect what's actually in your collection. You review the suggestions, pick what makes sense, and apply them. Nothing changes without you saying so. The deliverables are the plugin, the embedding and clustering pipeline, the recommendation system, and the review UI.
The Platform Parameters Dashboard project aims to enhance Oppia Android's developer options by introducing a user interface for managing platform parameters and feature flags. This dashboard will enable developers to dynamically view, override, and reset parameter values, facilitating real-time feature flag toggling without modifying source code. The implementation includes persistent storage of overrides, force synchronization with the Oppia Web backend, and comprehensive unit testing to ensure reliability. This feature will significantly improve debugging capabilities and streamline testing of various app configurations.
This project addresses the issue of translating complex marine biodiversity data into actionable knowledge for ecosystem management in Florida. It makes use of existing biodiversity datasets (OBIS, GBIF) and ecosystem variables (e.g., temperature) to develop a collection of reproducible Jupyter Notebooks powered by Python packages like pyOBIS, GeoPandas, and machine learning packages. These notebooks are dedicated to showcasing the top environmental inquiries in areas like the Florida Keys, Rookery Bay, Tampa Bay, and the Gulf of Mexico covering trends in Rice's Whale, birds, and seagrasses. The solution combines species occurrence records and ecosystem information to generate visualizations, spatial models, and biodiversity metrics. Interactive maps, temporal trend plots, and model-based habitat predictions are products. Constructed with reproducibility and open science principles in mind, the tools will assist resource managers, researchers, and decision-makers in conservation planning. Deliverables include: 5 modular Jupyter Notebooks (e.g., habitat models, trend predictions), Reusable data pipeline functions (data ingestion, cleaning, analysis), Public Docker-supported GitHub repository, Easy-to-read documentation and automated testing framework. The project facilitates environmental decision-making through data science and encourages collaboration through open, reproducible tools.
This project proposes the implementation of new Wagtail-specific keyboard shortcuts to enhance accessibility, navigation speed, and overall user experience, in alignment with ATAG Guidelines. The aim is to introduce keyboard shortcuts for key UI components such as the sidebar, Minimap, global search, and opening/closing the shortcut modal. In addition to adding these shortcuts, the project includes revising the user guide and keyboard shortcut modal to reflect both new and existing shortcuts accurately. These enhancements will make Wagtail more efficient and user-friendly, particularly for keyboard-driven users and those relying on assistive technologies.
This project will elevate Gemini API support across widely used open-source agent frameworks like LangChain, LlamaIndex, CrewAI, and Composio—bridging the gap between Gemini’s full capabilities and the tools developers use to build with it. By introducing support for advanced features such as multimodal inputs, structured function calling, and streaming outputs, I aim to empower developers to build highly interactive, context-aware agents with ease. The project will include contributions to core library integrations, detailed documentation improvements, and the development of end-to-end examples showcasing Gemini in action. The result will be a robust, user-friendly ecosystem for Gemini-based agent development—making it easier than ever for developers to harness its full potential within their own workflows, products, and research.
Time series clustering involves grouping similar time series data together based on specific features or patterns. Deep learning algorithms have become increasingly popular for clustering. However, the aeon's deep clustering module currently lacks several deep learning-based algorithms. In this project the aim is to implement some of the top performing and interesting algorithms from a recent comparison of deep learning for time series clustering and benchmark them. This project includes further developing the aeon deep learning networks module, making the package publicly documented for user to explore and well tested to help the maintenance of the deep learning implemented in the future.
Submitty, the TA grading interface is elaborate, highly-featured, and customizable. However, the interface is visually overwhelming to new graders, and some of our TA grading features are not adequately tested by automated unit and end-to-end (Cypress) regression testing. The primary goals for this project include the expansion of our automated testing of the TA Grading pages and patching bugs uncovered by this improved testing. And the project is to enhance the TA experience, especially for graders who are new to the interface and grading process.
The lack of automated testing capabilities in the cloud infrastructure of a data-intensive system significantly increases the time and effort required to ensure application quality. This is particularly cumbersome when the Quality Assurance (QA) team needs to set up its testing environments, connect to the development environment, and then execute test plans. A well-established CI/CD pipeline would support quality assurance and integration efforts, thereby streamlining the process. The objective of this project is to construct a CI/CD pipeline that automates the test suite execution process and improve test coverage comprehensively. This includes automated tasks such as adding authentication, installing dependencies, and configuring integration test scenarios, which are currently performed manually. By enhancing CI/CD and automating testing procedures, it will significantly reduce the team's time investment in the validation phase of the development cycle for the cloud system. This not only ensures the reliability and accuracy of D4CG platform’s data but also enables researchers to utilize this data to advance cancer research and increase opportunities for discovery.
Toolkit for Multivariate Analysis (TMVA) is a multi-purpose machine learning toolkit integrated into the ROOT scientific software framework, used in many particle physics data analysis and applications. Since it is part of the ROOT data analysis framework, it comes with an automatically generated Python interface, which closely follows the C++ interface. The goal of this project is to develop a generator in C++ and Python to read data from the ROOT I/O and input them to the Python machine learning tools such as Tensorflow/Keras and PyTorch. The main aim of the generator is to efficiently input data from the ROOT I/O system to train machine learning models, and keep in memory only the data required to train a batch of events and not all the data set.
Currently, the way to manage (CRUD) Jenkins X resources(pipelines) is by using the cli. While the CLI is very powerful and user friendly, it should be used by power users (release team who installs and manages jenkins x clusters). We should not expect developers who are concerned with only the pipelines to install the cli (This does not scale when you have 100+ developers in the company) We do have a UI/dashboard, but it is read only, so users cannot use it to trigger release pipelines or stop running pipelines. In addition, we do not have an audit trail of who did what. So, we propose a new UI/dashboard which has feature parity with the CLI (including SSO and RBAC) The UI should make the JX cli redundant, and add more value to the user with easily available status and logs of the entire cluster