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.
The project aims to find a better solution for handling files uploaded from Talawa clients. It seeks to store files outside the code tree, access them using reliable libraries, deduplicate files, encrypt them, store them consistently regardless of their characteristics, and screen them for malicious content. Additionally, the default storage must be accessible via the system's locally accessible filesystem, with cloud storage services discouraged.
There is currently no robust and unified sparse ndarray library that is compliant with the numpy API. This prevents the substitution of sparse arrays for dense arrays when needed in many data science workflows. PyData/Sparse is a repository that presents an opportunity to address these issues. In order to do so, there needs to be a C++ implementation of a code-generation algorithm that can generate efficient code for any type of sparse tensor operation. This abstraction allows one to maintain a relatively small piece of code that enables functionality for an exponential number of different sparse array format operations. The main objective of the project is to implement, test and document the merge lattice and its related data structures and algorithms that are vital for code-generation. This will result in a generalizable code-generation algorithm that can be applied for implementing a variety of different sparse ndarray formats that work together. This will involve interfacing heavily with the existing C++ code and its implemented templates to add functionality that constructs and manipulates a merge lattice, which is a useful abstraction in code-generation for sparse tensor algebra operations. As a few stretch goals, I plan on: i) implementing abstractions of what a sparse array is and what operations can be done that leverage this underlying core API, ii) finishing the co-iteration algorithm to account for non-unique and non-ordered levels and iii) begin work on the actual code-generation algorithm that leverages the merge lattice.
Biologically detailed models are essential tools in neuroscience, and automated methods are frequently used to build and validate such models based on experimental data. The open-source parameter optimization software Neuroptimus was developed to enable easy application of advanced parameter optimization methods, such as evolutionary algorithms and swarm intelligence, to various problems in neuronal modeling. Neuroptimus includes a graphical user interface, and works on various platforms, including PCs and supercomputers. While Neuroptimus uses various built-in cost functions and the eFEL feature extraction library to compare model behavior to experimental data, it severely limits the range of neuronal behaviors that can be targeted by optimization. However, the popular model-testing framework SciUnit allows for the implementation of tests that quantitatively evaluate arbitrary model behaviors. Therefore, the goal of this project is to extend Neuroptimus to use HippoUnit, an open-source neuronal test suite based on SciUnit, to evaluate model performance during optimization. This project aims to develop a seamless integration between HippoUnit and Neuroptimus, enabling the construction of detailed biophysical models of hippocampal neurons. The new Neuroptimus-HippoUnit integration will allow the optimization of a broader range of neuronal behaviors, which can ultimately lead to improved biophysical models of hippocampal neurons. Deliverables: 1- Implementation of an interface between HippoUnit and the new version of Neuroptimus to enable the optimization of a broader range of neuronal behaviors. 2- Extend the current supported tests to include all HippoUnit tests. 3- Integrate the HippoUnit with the Neuroptimus’s GUI so that users can run optimizations directly from the interface.
The goal of this GSOC program is to automate the processes around project governance. This project aims to automate maintaining the Maintainers.yaml file which contains the list of maintainers and TSC members of AsyncAPI. The tasks involve implementing workflows to automatically update the member's list based on changes in other files, inviting new maintainers and TSC members, updating the Emeritus.yaml file when someone is removed, and aggregating helpful information in the Maintainers.yaml file. These automation and improvements will make it easier to manage the maintainers and TSC members of AsyncAPI.
This project aims to build a Julia package for probabilistic modeling based on static directed graphs. Specifically, we want to enable users to execute programs previously written in BUGS(Bayesian inference Using Gibbs Sampling) directly in Julia.
Event-based vision is a subfield of computer vision that deals with data from event-based cameras. Event cameras, also known as neuromorphic cameras, are bio-inspired imaging sensors that work differently to traditional cameras in that they measure pixel-wise brightness changes asynchronously instead of capturing images at a fixed rate. Since the way event cameras capture data is fundamentally different to traditional cameras, novel methods are required to process the output of these sensors. In addition to dealing with ways for capturing data with event cameras, event-based vision encompasses techniques to process the captured data - events - as well, including learning-based techniques and models, spiking neural networks (SNNs) being an example. This project aims to create benchmark datasets for object recognition tasks with event-based cameras. Using machine learning solutions for such tasks requires a sufficiently large and varied collection of data. The primary goal of this project is to develop Python utilities for augmenting event camera recordings of objects captured in an academic setting in various ways to create benchmark datasets. A secondary goal of this project is to test the performance of spiking neural networks for object recognition on the created datasets.
I propose to add new loss functions which make improvements over the existing ones for metric learning. I also propose to improve documentation and add code examples to show how to make use of this library.
<p>The goal of this project is to develop a failure detection, isolation and recovery algorithm (FDIR) for a cubesat, but using machine learning and neural networks instead of the more traditional methods.</p>
<p>The functioning of complex systems (i.e. the brain, and many others) depends on the interaction between different units; crucially, the resulting dynamics is different from the sum of the dynamics of the parts. In order to deepen our understanding of these systems, we need to make sense of these interdependencies. Several tools and frameworks have been developed to look at different statistical dependencies among multivariate datasets. Among these, information theory offers a powerful and versatile framework; notably, it allows detecting high-order interactions that determine the joint informational role of a group of variables.</p> <p>The goal of this project is to collect and refine existing metrics of high-order interactions currently implemented in Matlab or Java, and integrate them in a unified python-based toolbox. The main deliverable of the project is a toolbox, whose inputs are the measurements of different variables plus some parameters, and whose outputs are the measures of higher-order interdependencies. Ideally, the toolbox will interface with visualisation & processing platforms of neuroimaging data, such as MNE, fMRIPrep and can become a docker container too.</p>
<p>Model Bricks project is an effort focused on describing recurring patterns in biological networks. These patterns are described as small VCell models that are retrieved from the VCell database and displayed online. To make Model Bricks recurring patterns more efficient and easily accessible, an entire code base shift from YAML to Vue.js is proposed. Vue.js features an incrementally adaptable architecture that focuses on declarative rendering and component composition. Vue.js component system will enable us to organize VCell APIs appropriately.</p> <p>The main objectives of this project are:</p> <ol> <li>Enhance Modelbricks.org user interface by using modern web design trends.</li> <li>Create a well-organized web architecture that will allow displaying of as many VCell elements as possible.</li> <li>Create VCell APIs for each element to be displayed.</li> <li>Enhance VCell user interface features to enable their display online.</li> <li>Write appropriate documentation.</li> </ol>
<p>The idea is to update ParameterJuMP.jl to enable users to add parameters to JuMP arithmetics in linear mode. By doing so, users will be able to modify constraints as the parameter values changes, as well as extract useful information. This is allow a more efficient implementation for Stochastic Optimization methods, expanding JuMP's flexibility.</p>
<p>As of now, Monkey covers 24 attack techniques from the MITRE ATT&CK matrix. This project aims at increasing the number of techniques by adding 11 new techniques from different categories including persistence, privilege escalation, defense evasion, and discovery.</p>
<p>jQuery UI is formally deprecated among MediaWiki Developers, but Extension: Page Forms still uses it. So, it would be great to replace it with other libraries.</p>
<p>Currently, Atarashi has 4 active agents types that use 9 different types of algorithms to find the similarity between license statements. According to the evaluation of all the agents and their types, it can be seen that there is a need for improvement in the speed as well as the accuracy of the agents. I’ll be implementing the basics of Lucene and percolate search on the top of different agents to increase the speed of the agent without much tweaking with their original algorithm.</p> <p>A python library for code comment extraction is needed to be created with various additional features for providing support to Atarashi as well as FOSSology. This will be packaged & published to PyPI for easy installation and usage.</p> <p>For any Machine Learning/Deep Learning model to be implemented we need a dataset of SPDX open-source licenses. There isn’t any dataset available online so we need to create our own dataset as per the requirements.</p> <p>I’ll be working on the improvement of the semanticTextSim agent and will be introducing a new part of it. Currently, we have doc2vec implementation and I’m planning to introduce the BERT embeddings for finding semantic text similarity.</p>
<p>Audio Worklet, an extension to the Web Audio API currently available in Google Chrome, allows developers to write their own AudioWorkletNodes that will run audio processing code on a separate thread. This replaces the deprecated, less efficient ScriptProcessorNode, which runs on the main UI thread.</p> <p>For this project, I will replace all instances of ScriptProcessorNode in p5.Sound with AudioWorklet, with a polyfill for browsers that don’t yet support AudioWorklet. This will improve the efficiency of the p5.SoundRecorder and p5.Amplitude nodes, and possibly also p5.SoundFile.</p>
<p><code>imjs</code> and <code>im-tables</code>, written in CoffeeScript are client-side libraries for querying mine instances and displaying data in tabular format respectively, which help in reducing boilerplate code for developers, looking to work with InterMine's services. The aim of this project would be overhauling these libraries, by upgrading their dependencies (last updated in 2015) and adding easily extensible mock responses (in <code>imjs</code>). Moreover, the test suite will be broken up into unit and integration tests. Support for querying with the Registry class will be added. Docs for both libraries will be added (adding end-user docs for <code>imjs</code> and developer docs for im-tables). Build system of both the libraries will be investigated, and the possibility of updating it will be discussed and implemented (possibly in the GSoC period itself, if feasible as per investigation). High priority issues, like adding support for <code>setConstraintLogic()</code> in <code>imjs</code> will also be resolved.</p>
<p>digiKam is KDE desktop application for photos management. In digiKam, tags on photos are strongly supported for the sake of providing users with a natural workflow of searching and arranging photos in their collections. Since many of our photos contain faces, face tag has apparently emerged as an essential property for any photos management software, also with the fact that user has to tag thousand of their photos manually. Being aware of that, digiKam team has put a lot of efforts to develop face engine, capable of scanning photos and suggesting face tags automatically basing on pre-tagged photos by users. However, that functionality is currently deactivated in digiKam, as it is slow while not adequately accurate. Thus, this project aims to improve the performance and accuracy of facial recognition in digiKam by exploiting state-of-the-art neural network models in AI and machine learning.</p>
<p>Implement necessary tools for rank metric McEliece cryptosystems. Namely finish work on rank metric and Gabidulin codes (tickets #21226 and #20970). Use these to create a McEliece cryptosystem class with encoding and decoding.</p>
<p>The primary goal of this project would be to implement a solution to issue #3047. This issue is basically about implementing a way for users to select a face and choose it to be the face that connects to the plate. Specifically, after implementing this feature, I expect that a user would be able to click a face (which should be highlighted to make clicking the right face easy) on an object and then click menu button to rotate that face to bottom of the model. If there is a part of the object below the plate after the rotation, it should either error or push the model up until it is no longer intersecting the plate (I’m not sure which is more intuitive).</p>
<p>My proposal is focused on making certain improvements in Zulip that are considered prioritary, with the goal of providing high-value contributions in consonance with the project's roadmap.</p> <p>Most of Zulip's REST API is currently undocumented, which is a pity considering how powerful it is. The first project in my proposal is to solve this by working in our <strong>Swagger/OpenAPI docs</strong> until we have a 100% documented REST API. The relevant code examples will also be updated so we can provide fully functional scripts that show how to use it, as well as extending our Python bindings to cover all the endpoints the API provides.</p> <p>The role that API keys play is also quite important, especially now that our integrations system is becoming more and more robust and we have many different clients for interacting with Zulip. That's why having <strong>multiple API keys per user</strong> could be very useful in terms of user account security and convenience. The second part of my project consists in implementing this feature in Zulip's backend, so normal users can have as many API keys they consider necessary (e.g. one per client), keeping authentication tokens isolated between applications.</p>
<p>Worldbrain - Memex already has analytics but they’re limited. This proposal involves storing, tracking and analysing an event log of the user activity, both on individual and whole user-base levels.</p>
<p>At present, <a href="https://bugzilla.mozilla.org" target="_blank">bugzilla.mozilla.org</a> uses enter_bug.cgi to file bugs. This is particularly unwieldy due to a lot of reasons like two hop db access, backend template rendering and multiple views. This project aims at improving the current bug filing scenario by creating a new single page interface to file bugs, thereby increasing the overall performance and usability</p>
Millions of lines of open-source Verilog exist but remain verbose and hard to maintain. TL-Verilog offers a cleaner abstraction, but almost none of this codebase has been converted. This project strengthens the LLM-driven conversion pipeline in the conversion-to-TLV repository by improving error recovery, refining prompt recipes for complex Verilog patterns (FSMs, parameterized modules, arithmetic pipelines), and applying the flow to real open-source modules including RISC-V components. All conversions are formally verified using SymbiYosys and EQY, generating high-quality training data for future LLM improvement. Deliverables include a fast working failure-classification system, improved prompts.json recipes, 10+ converted and verified modules, and structured training data registered in the project repository.