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.
<p>Pocket Science Lab is a complete and powerful tool that can really power a regular science lab. It can work as Oscilloscope and Logical Analyzer. PSLab can generate desirable waveforms, voltages, currents and pwm signals, it can read resistance, capacitance and data from sensors (wireless/analog/digital). Its features have opened new horizons for engineers, teachers and students. As we live in 21st century, where Smartphones are possessed by the majority of people, it is important that the features of PSLab can be accessed via Smartphone. This proposal aims towards the development of an Android application for PSLab experiments. The proposal proposes an entire model contributing towards the development of the project. It starts with discussing various aspects of the project and defining its goals. Then it focusses on project implementation, the software lifecycle to be used and the modules in which the system can be divided into. Subsequently, it states application’s ideology and thoroughly explains each module (along with wireframes). It also presents a timeline of the entire project. The proposal concludes by discussing development and testing phase of the project.</p>
The goal of this project is to develop a fully configurable Android Virtual Printer application that simulates real printer behavior using the Internet Printing Protocol (IPP). This tool will allow developers, QA engineers, and ChromeOS/Android teams to debug and test printing workflows without requiring physical printer hardware. The app will function as an IPP-compatible printer on the network, responding to print jobs, processing documents, and allowing users to configure printer capabilities by uploading or directly retrieving IPP attributes from real printers. It will also support advanced features like print job simulation, plugin-based behavior injection, and exportable logs for deep debugging. This virtual printer will empower developers to reproduce and fix complex bugs, simulate diverse printer setups, and even integrate testing in CI pipelines — all through a user-friendly Android app. By combining protocol-level accuracy with intuitive design, it offers a powerful emulation environment for printer-related development and troubleshooting.
<p>The project intends to integrate Todoist with GNOME To Do allowing the users to manage their Todoist account using GNOME To Do. Implementation of Todoist will require a OAuth2 authentication and implementation of Todoist Provider that manages loading/editing tasks/ task lists and saving changes to Todoist Server. We would use GOA's already implemented OAuth2 authentication, by adding a Todoist Provider in GOA which will manage users login and store the access tokens. The Todoist plugin inside To DO will make use of the todoist v7 API to make sync calls for process like loading tasks,lists or updating tasks etc. Todoist server responds to every request with a JSON response. The Todoist provider would check the JSON response for error and if correct process it to retrieve requested data. At the end of the project we will have a working Todoist plugin which will be a nice addition to To Do. Beside this, the project will take care of some feature implementations currently being used in Todoist and also general bug-fixing if time permits.</p>
<p>Eigen is a C++ template library for linear algebra that aims for high performance in combination of high reliablity and good compiler support. A lot of remarkable projects rely on it, including Google's Tensorflow. Another successful project using Eigen is the high-energy physics experiment ATLAS at the LHC.</p> <p>At the LHC, millions of particles collide every second and each collision creates a huge amount of data that has to be classified and analyzed by software. Most algorithms in ATLAS software use symmetric matrices, i.e., matrices where the upper triangular part is equal to the lower triangular part. Unfortunalty Eigen currently misses support for symmetric matrices.</p> <p>This Google Summer of Code 2018 project aims to implement a class for handling symmetric matrices in Eigen. The goal is to provide a working implementation that can be submitted as a patch for Eigen.</p> <p>This project proposal contains implementaions ideas and plans, a detailed implementation timeline, consisting of 13 weekly tasks and some short biographical information about me.</p>
<h3>Current State</h3> <p>Users are required to manually open untrusted files through a right-click dialog each time they want to access them in a Disposable Virtual Machine. This not only places a high amount of responsibility on the user, it also poses a security risk if they accidentally open the file locally, calling for a shutdown of the Virtual Machine in order to eliminate any potential damage caused by the file's execution.</p> <h3>The Proposal</h3> <p>In this proposal a more convenient and less error-prone method of opening untrusted files is presented. By allowing the user to mark a folder, file or file type as untrusted, the need for a user to constantly keep themselves in check is eliminated, and unnecessary actions that must be frequently repeated during the course of working with sensitive or semi-trusted data are discarded.</p> <p>These features and implementations are discussed in detail along with possible future developments should there be excess time towards the end of the event. The proposal concludes with a complete timeline as well as a description of myself, my community experience and various methods of keeping in contact.</p>
The enviroCar Android app provides capabilities for visualizing user related tracks within a map. For this feature, the app makes use of several libraries of the Mapbox mapping framework. However, recent changes in the terms-of-use of Mapbox as well as their switch to a non open-source license makes it problematic to continue relying on Mapbox. MapLibre Native library for Android is an open-source alternative to Mapbox mapping framework. Migrating to MapLibre will ensure the project's adherence to open-source principles & long-term sustainability. Mapbox's current issues are preventing many developers in the open-source community from participating in the further development of the enviroCar app. Thus, this project aims to add support for multiple map providers (primarily MapLibre) into the enviroCar Android application. This will be done by introducing a new extensible and independent map module into the project's source-code. This map module will allow the users to select the preferred map provider/library based on their requirements, both during compile-time and run-time of the application.
<p>JPF does not yet fully implement the features of Java 11 - support extends only to Java 8 - including features as simple as string concatenation. This is an especially difficult situation given that Oracle has initiated an “end of public updates process” for Java 8 (although it is interesting to note that Oracle will continue “premier support” for Java 8). It is likely that many Java users will migrate to higher versions, and unless JPF fully supports the new features of a higher version of Java it is unlikely to be used and adopted.</p> <p>A crucial feature of Java 11 that needs to be urgently implemented is support for bootstrap methods that are generated and resolved at load time. These are used in Java for things as varied as string concatenation and lambda expressions. It is likely that more features of Java will take advantage of bootstrap methods as we go forward, so it is desirable to have a complete bootstrap method resolution engine in the JPF runtime that complies with the Java Virtual Machine 11 (JVM 11) specification for JPF to remain current.</p>
<p>The objective of this project is to develop a novel closed form Perspective n Point (PnP) pose estimation algorithm for a monocular camera. A variety of techniques have been developed to estimate the pose using a monocular camera. However, the algorithms developed do not meet the simultaneous requirement of computation time, precision and efficiency. The proposed algorithm, Linear Least Squares (LLS-PnP) would minimize the cost function (non-linear error norm) which can be explicitly expressed as a quadratic function of the rotation matrix. The position is eliminated using least squares formulation. This leads to the possibility to solve the estimation problem in a closed form w.r.t. the rotation matrix. The proposed algorithm will break new grounds in computer vision and can be extended for pose estimation using Stereo vision. The final product (toolkit) will comprise of the new algorithm and the state-of-the-art PnP algorithms, which will provide the end user the choice to choose any given algorithm as well as to enable performance comparison between the various algorithms.</p>
<p>My project aims to improve the existing API of the control system module in <code>sympy.physics</code>. Not to mention <code>sympy.physics.control</code> utilizes the state-of-the-art symbolic features of SymPy, making it more beginner-friendly than any other controls module present. Basic functionalities of a Linear Time-Invariant (LTI) control system package were added last year by Naman as part of his GSoC project. These included <code>TransferFunction</code>, <code>Feedback</code>, <code>Series</code> and <code>Parallel</code> classes. Although being available in the latest release of SymPy (v1.8), these functionalities require further improvements before becoming fully useful for an engineer or a student. Apart from these modifications in the original implementation, I plan to add some of the missing features to complete the LTI submodule. These include-</p> <ul> <li><code>TransferFunctionMatrix</code> for MIMO systems. Quality examples will also be added to the documentation covering the various possibilities before any further development is carried on.</li> <li>Stability analysis plots.</li> </ul>
The current Continuum Mechanics has been undergoing continuous developments in the past years and has developed functionalities for solving and analyzing various structures which are important in the field of Mechanics like Beam, Truss and Cable. This project aims to improve the existing classes by implementing additional functionalities for plotting various graphs and diagram related to the existing structures in the Cable Module and introducing new classes to solve and analyze the Arch structure and introducing some new features for other existing classes. The features planned to be implemented for the Arch structure is a solver for finding the internal forces, reactions, bending moment developed in the Arch under external forces and moments and methods to get a detailed diagram and plot forces generated in the structure. The improvements in the Cable class would allow the user to plot the tensions developed in the Cable under various types of external loads and also get a detailed diagram which would be helpful in analyzing various details like the position and shape of the cable. The project's implementation will expand Sympy's capabilities, allowing users to tackle a broader range of engineering problems with ease.
<p>The usual approach taken in computational chemistry is to first run a simulation, which can often be long, on a target molecule and then to analyze the results to obtain an insight about the molecule. Usually, electron density assigned in the atoms that constitute the molecule is a key element in this process. This partitioning of the electrons itself do not suggest any observable properties of a molecule. However, many observable features of a molecule are derived directly from the electron densities, hence motivating chemists to relentlessly improve this <em>noumena</em> step by step. Currently, cclib can calculate some common atomic charge potential methods, including C-squared Population Analysis, Mulliken Population Analysis, and Lowdin Population Analysis. Because Mulliken Population Analysis and Lowdin Population Analysis are similar in its theory (Lowdin uses a different basis set to reduce the basis set dependence observed in Mulliken Analysis), it would be advantageous to have other modern calculation methods implemented in cclib. Some examples of the methods that can be implemented include DDEC6, Hirshfeld method, Bader analysis, ISA (through a bridge to Horton) and so on.</p>
This project addresses the critical need for a software-defined ground station receiver to support the LibreCube proto-LC2302, an open-source UHF CubeSat communications module. To solve this, we propose the development of a resilient receiver architecture utilizing Software-Defined Radio (SDR) and the GNU Radio framework. The system will ingest baseband IQ data, perform signal demodulation, and execute a complete Consultative Committee for Space Data Systems (CCSDS) decoding chain, including frame synchronization, deframing, and forward error correction (FEC). Key project deliverables include fully functional GNU Radio flowgraphs for both live SDR reception and recorded playback, curated test datasets, and comprehensive documentation. Furthermore, the project explores the optional development of custom C++ Out-of-Tree (OOT) blocks for supplementary processing, alongside integration with the Yamcs mission control suite. Ultimately, this work provides an end-to-end telemetry acquisition system, bridging the gap between open-source space hardware and standardized communication protocols.
This project implements a browser-native genomic feature search system for efficiently querying large GFF3 annotation datasets without requiring backend infrastructure. Traditional approaches either rely on slow client-side parsing or require server-side APIs, both of which introduce scalability and maintenance challenges. The proposed solution converts GFF3 files into an indexed SQLite database offline and performs full-text search queries directly in the browser using SQLite WASM within a Web Worker. The system integrates with JBrowse to enable seamless navigation from search results to genomic locations, providing a responsive and interactive user experience. To support large metagenomic datasets, the system will incorporate range-based loading and progressive data access strategies. The final outcome will include a production-ready indexing pipeline, a browser-based query engine, performance benchmarks, and a reusable React component that can be integrated across multiple EMBL-EBI web applications without requiring backend services.
<p>Currently the stats module lacks some useful features as suggested on the ideas page, like Random Walks, Random Matrices, etc. There is also a scope of completing the work of GSoC 2018 by Akash Vaish like, exporting expressions of random variables to external libraries. There are also certain issues with results being produced by various functions and methods, like, sometimes unwanted complex results are produced for simple probability expressions or, unevaluated results are given as output. I would divide my project into the following broad categories:</p> <ol> <li>Implementing additional multivariate distributions.</li> <li>Implementing Markov Chains, Random Walks, Bernoulli Process(extending PR #15058), and Poisson Process.</li> <li>Implementing Random Matrices.</li> <li>Implementing mechanism to export random variables to PyStan, PyMC3, NumPy, etc. </li> <li>Adding support for assumptions of dependence among random variables.</li> <li>Adding support to enhance result generation by statistics module.</li> </ol>
<p>The CLTK features the most sophisticated algorithm available for lemmatizing classical Latin. Lemmatization is the process by which inflected word-forms are grouped together under their dictionary headings. This allows us to gather accurate word-usage statistics, analyze authorship, and model subject matter in classical corpora. However the CLTK lemmatizer is not currently able to identify synonyms for a given word, or suggest translations into other languages.</p> <p>I propose to modify the existing CLTK lemmatizer to look up synonyms and translations for Latin and Greek. I will adapt CLTK’s unique ‘backoff’ approach to lemmatization in order to measure the probability of each possible synonym and/or translation for a target word given its context. Further, I propose to incorporate vector models for Latin and Greek based on word embeddings trained using the word2vec algorithm. Once synonyms, translations, and vector models are incorporated into CLTK, users will be able to perform cutting-edge tasks like sentence length document alignment. This will open new horizons for digitally assisted classical scholarship.</p>
<p>Measuring the similarity between two geometric models is an important problem in diverse fields, including computer graphics, computer games, and geometric modeling. For example, they can be used in terms of benchmarks to determine the variance of a processed geometry from a given ground-truth model.</p> <p>One such similarity measure is the Hausdorff distance. Given two compact subsets A, B of a metric space, the one-sided Hausdorff distance between A and B is defined as the distance between an element a from A and an element b from B, where a is chosen to maximize the distance and b is chosen to minimize it. Intuitively speaking, the Hausdorff distance measures the maximum deviation between two models.</p> <p>The project consists of implementing the algorithm for interactive Hausdorff distance computation presented by Tang, Lee, and Kim. While it provides an approximation to the Hausdorff distance - as already present in the CGAL framework - it ensures the computed measure to be within a user-specified error bound. Thereby, the user can obtain as good results as necessary for the applications at hand within a fast and efficient pipeline.</p>
<p>The Compact Muon Solenoid (CMS) experiment is one of the largest experiments at Large Hadron Collider (LHC) that has been built to search for new physics. CMS Software (CMSSW) is the framework utilized by the CMS experiment for Data Acquisition, Trigger and Event Reconstruction. The future upgrade of the LHC will add new challenges for CMS detector due to the larger amount of data that will be produced. One solution is to look towards a heterogeneous High-Level Trigger (HLT) Computing Farm, where the computing load can be distributed among different hardware (CPU, GPU, FPGAS). This project aims to use Portability Libraries like Alpaka to write code for the CMS Software (CMSSW), in order to have a single implementation which will be compiled on different architectures. In the last years, a new pixel track reconstruction that can run on GPUs (CUDA) has been implemented. The goals are to port the current CUDA implementation with Alpaka, in order to understand if this library is feasible for CMSSW and to compare the timing performances between Alpaka implementation and native CUDA.</p>
The project looks at how to facilitate the process of Telecom roaming agreements drafting and negotiation. The project looks at first constructing a library of drafting articles with a set of variables that will be extracted from the available templates and previous roaming agreements using Natural Language Processing process NLP. The second part will be towards translating the drafting and negotiation process as a chaincode on Blockchain to digitalize the process and provide a maintainable and actionable copy of the agreement. The project focus on how to be able to digitalize the legal process and make it automated through smart contracts to be more efficient and less error prone. The expected outcome of this project, would include: 1. Building a drafting library and an NPL model that will include a digital version of the most relevant and important articles in a the GSMA AA.12, AA.13 and AA-14 roaming agreement templates. 2. Developing a chaincode that will map all steps of the drafting and negotiation business processes for roaming agreements. 3. Building a PoC for UI to handle the agreement construction 4. Writing a solution document summarizing the implementation details
First responders file the same incident data across multiple agencies - fire, EMS, law enforcement, county/state each with different forms and formats. This redundant data entry costs hours per shift and increases error risk. I propose building FireForm's complete processing pipeline: a responder speaks or types once, a locally-hosted LLM extracts structured data through a schema-aware multi-step pipeline with validation and completeness tracking, and the system generates all required agency PDFs automatically. A visual template registry allows any agency to register new forms without code changes. Missing data is tracked per form and can be supplemented incrementally. Deliverables: REST API with agency-scoped access control and async job processing, schema-aware extraction pipeline with validation layer, visual template editor and registration API, coordinate-based PDF generation, completeness tracking with form generatability status, supplement and manual patch endpoints, test suite with CI integration, and developer documentation.
OpenStreetMap (OSM) commonly stores names of streets, places, and points of interest in their local language and script. As a result, users searching in unfamiliar regions may receive results that are unreadable—especially when those names are rendered in non-Latin scripts like Cyrillic, Arabic, or Chinese. This project will enhance Nominatim, OSM’s geocoding engine, by adding transliteration support to its search results. The goal is to detect when names are in a script unfamiliar to the user and provide a readable transliteration alongside the original. This involves detecting the script of place names, selecting an appropriate transliteration library (e.g., pyicu, unidecode), and integrating a new transliterated_name field into Nominatim’s output format. The solution will be designed to be modular and extensible to multiple languages and target scripts. Deliverables include a working transliteration pipeline, user-configurable options, improved search result formatting, robust test coverage, and complete documentation. This will make OpenStreetMap data more accessible to users worldwide by bridging language and script barriers during location search.
<p>Web is the most vibrant open computing platform. With huge multimedia contents available on web, web developers are in need of wide array of image and vision processing algorithms in JavaScript to build innovative applications, such as facial detection in live WebRTC streaming. And this requirement is even more essential for emerging usages on web, such as Web Virtual Reality and Augmented Reality (WebVR). The OpenCV is the de-facto standard C/C++ library for image and vision processing extensively used by computer vision community. But OpenCV is unavailable to web applications today. Thanks to OpenCV.js, an open source project initiated in Parallel Architectures and Systems Group at UC Irvine, by utilizing Emscripten LLVM-to-JavaScript compiler, it makes the first step to prove OpenCV can be exposed to web with high performance. This proposal aims to merge OpenCV.js into official OpenCV repository which makes JavaScript as one of the language bindings of OpenCV. So it requires refactoring the structure, addressing several shortcomings and code optimization of existing OpenCV.js.</p>
Fablo is a tool mostly used for local development and in CI. Is starts a Hyperledger Fabric network from a single configuration file, and supports various features that makes the development easier (REST API, network snapshots, advanced topology configuration, hooks, etc). Currently it supports Hyperledger Fabric in versions since 1.3 to 2.5. With the new upcoming release of Hyperledger Fabric (version 3): - We want Fablo to support Hyperledger Fabric v3, along with BFT consensus - We want to drop support for Hyperledger Fabric v1.3 and v1.4. - Optionally, we want to approach support for Fablo on ARM architecture (Apple M; running ARM Docker images for Fabric). Mentee will work with Bash scripts that are used for calling Fabric, TypeScript code for validation and normalization of config, and template engine to generate parametrized configs. Also mentee will be responsible for creating automated tests (both TS unit tests and e2e tests in Bash), covering implemented features, and updating Fablo documentation.
<p>The Plasma desktop does not have a hard dependency on any login manager, but the SDDM (Simple Desktop Display Manager) login manager is the recommended option. SDDM used in conjunction with Plasma, however, results in certain issues, some of which fall under the guise of consistency between the login screen and the desktop. In practice this means that as soon as there is any relevant veering from Plasma defaults, the login manager no longer provides an identical visual experience. This GSoC project would try to solve that very issue by adding the possibility of syncing the desktop and login manager options. Options that could be synced are: color scheme, font, font size, font rendering, icon theme (obtained from the Plasma theme). Rather than adding discrete options, the suggestion is to have only one option that would pertain to syncing SDDM settings with a particular user’s settings. Patching SDDM to support Plasma wallpapers would also fall within the scope of the project. Most importantly, because desktop display scaling preferences are likewise not respected in SDDM, the project would also tackle the issue of allowing users to set a display scaling preference via GUI.</p>
<p>R package developers currently use ad-hoc tests of asymptotic computational complexity via empirical timings of functions and visual diagnostic plots. However, there is no framework in R for systematically testing the empirical computational complexity of functions, which tends to be a problem because such a testing framework could be essential for identifying big speed gains in R code as well. In response to improve the stated, this project brings a new package 'testComplexity', which provides a suite of functions that will be useful for testing and thereby improving the speed (via code optimization) of various algorithms/functions in R. It quantifies the runtimes for an algorithm, classifies its time complexity trend, tests for an expected complexity class and plots the benchmarked results to help visually conceive the results. Additionally, other features such as quantifying memory allocations, subsequently predicting the space complexity class and classifying complexity for user-defined output parameters (apart from time/memory cases) have been implemented. Since algorithms are used in every sphere of research, this package potentially caters to all types of R-users.</p>