Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
3883 Projects Found
Sort by

Implementation of a Reservoir Computing library for timeseries prediction

beginner
The Julia Language•2020Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
90h (Small)

<p>A leap forward in the accuracy of forecasting problems in chaotic time series has been recently obtained using Echo State Networks (ESN). This is a novel kind of recurrent neural network with a randomly connected hidden layer, called the reservoir, and an adaptable output layer trained using a simple regression algorithm. This architecture has the advantage of faster computation and presents less parameter tuning then a standard neural network. Since their inception there has been a lot of effort towards the improvement of the model and applications have been found in several fields of study: anomaly detections in geophysics , short term predictions in astrophysics and reconstruction of chaotic attractors among others.</p> <p>This project aims to build a comprehensive Julia package in which are implemented the majority of the variations of the ESNs presented in the literature. Such an effort would represent the first attempt to create a library for this kind of models in any programming language, and would reap benefits not only for the consequent simplicity of application, but also for showing the actual state of the art in a family of models that has yet to go mainstream.</p>

cjavascriptc+++12
Student: MartinuzziFrancesco
Code
Proposal

Named Entity Recognition and Part-of-Speech APIs and models

intermediate
The Julia Language•2019Varies175h (Medium)

<p><a href="https://github.com/JuliaText" target="_blank">JuliaText</a> is the JuliaLang organization that provides with packages to work with text. It currently lacks support for basic problems like Named Entity Recognition, Part-of-Speech Tagging, Dependency Parsing etc. which help serves as the basis for various language processing problems and analysing text.</p> <p>I propose to implement practical models for Named Entity Recognition and Part-of-Speech Tagging in Julia and extensively test and validate them. Robust and well-tested APIs for these two tasks will be written.</p>

cjavascriptc+++12
Student: Ayushk4
Code
Proposal

ParallelGraphs: A General Purpose Graph Processing Library.

intermediate
The Julia Language•2016Varies175h (Medium)

<p>I hope to develop a package, ParallelGraphs, that enables the analysis and manipulation of massive graphs in a distributed environment. The package will adhere to two separate computing models; The first being the vertex centric Pregel model that relies on Bulk Synchronous Parallel infrastructure. The second model is a combinatorial approach that involves matrix operations such multiplication and vector indexing on distributed sparse matrices. ParallelGraphs will enable users to process graphs using sequential algorithms on smaller graphs. This will be accomplished by providing compatibility with LightGraphs.jl. The package will also experiment will CPU/GPU parallel algorithms with an aim of unifying all graph computation models in a single package.</p>

cjavascriptc+++12
Student: pranavtbhat
Code

Extending GraphNeuralNetworks.jl to support Temporal Graphs

intermediate
The Julia Language•2023Varies175h (Medium)

The purpose of this project is to add Temporal Graph Neural Networks (TGNNs) to GraphNeuralNetworks.jl. The first part of the project will be dedicated to creating a temporal graph type and providing it with all the accessory functions. After that, new layers will be added to the package to build models that fall under the category of STGNNs. Thus, new datasets of temporal graphs will be included in MLDatasets.jl to be used for training the models. Finally, tutorials will be produced to complete the project, introducing the new temporal graph type and showing how to perform temporal graph tasks using the added data, model and features.

cjavascriptc+++12
Student: Aurora Rossi
Code
Proposal

Image Features and Exposure Correction using Images.jl

intermediate
The Julia Language•2016Varies175h (Medium)

<p>My Proposal is to develop a feature detection and extraction package for Julia, ImageFeatures.jl. Alongwith feature detection and extraction, I will work on adding exposure correcting functions to <a href="https://github.com/timholy/Images.jl" target="_blank">Images.jl</a>. I plan to add the following functions over the course of the coding period :</p> <ul> <li>BRISK Descriptors</li> <li>FREAK Descriptors</li> <li>ORB Descriptors</li> <li>GLCM</li> <li>LBP</li> <li>BRIEF Descriptor</li> <li>CENSURE Keypoint Detector</li> <li>FAST Keypoint Detector</li> <li>Histogram Matching</li> <li>Histogram Equalisation</li> <li>Gamma Correction</li> <li>CLAHE Algorithm</li> </ul>

cjavascriptc+++12
Student: mronian
Code
Proposal

ColBERTv2.0: Efficient, late-interaction retrieval in Julia.

intermediate
The Julia Language•2024Varies175h (Medium)

This projects aims to bring the well known ColBERTv2.0 information retrieval system to Julia! In this project, we aim to implement various components of the ColBERT model, with the major focus on indexing and search. Being a late-interaction retrieval system, ColBERT isolates all the computations between the queries and documents to enable pre-computing the document embeddings offline. Combined with a RAG pipeline as an embedding and retrieval backend, ColBERT can make the usage of existing AI tools really powerful. As part of the project, we also aim to apply this model to Julia's own extensive documentation (over thousands of packages), and integrate ColBERT with AIHelpMe.jl and PromptingTools.jl. Combine this with a locally hosted LLM, all Julia users get a powerful, modular, and easily hackable local AI assistant, allowing them to integrate ColBERT with their own RAG pipelines. The main deliverable of the project will be a new package (called ColBERT.jl), with the implementation design inspired from the original Python implementation of ColBERTv2.0 (i.e the centroids + residuals compression method). The project will also have an extensive number of addons, including, but not limited to, implementing the training module for this package, which will allow users to train their own ColBERT models instead of relying on pretrained checkpoints, and distributed training (using existing art like DaggerFlux.jl).

cjavascriptc+++12
Student: Siddhant Chaudhary
Code

Julia Dagger - Enhancing Streaming Data Processing for Heterogeneous Computing

intermediate
The Julia Language•2024Varies175h (Medium)

This project is aimed at advancing the capabilities of heterogeneous computing environments in Julia through Dagger.jl. We propose to implement a series of enhancements for significantly improving task execution efficiency, data transfer speed and robustness of distributed parallel computing systems. We place special emphasis on further development of streaming data processing for distributed heterogeneous systems with Dagger.jl. Heterogeneous computing environments leverage a combination of resources - such as CPUs, GPUs, DPUs - and face challenges in optimizing task execution and data streaming. Data transfer mechanisms are often inefficient or may lack robustness against system slowdowns or failures. The project will be supporting ongoing radio astronomy and ionospheric RADAR work at MIT and its Haystack Observatory — bringing about real-world impact in the short-term.

cjavascriptc+++12
Student: Davide Ferretti
Code

MLJTime - Adding Time Series Support For MLJ

intermediate
The Julia Language•2020Varies175h (Medium)

<p>The main goal of the project is to port capability from​ sktime​ (Machine learning for time series) to MLJ universe &amp; develop data container to handle time series data in modular, composable way.</p>

cjavascriptc+++12
Student: Aadesh Deshmukh
Code
Proposal

Improving and demonstrating Julia statistical models' MCMC: CrossCat example

beginner
The Julia Language•2017Varies90h (Small)

<p>General-purpose statistical modeling tools such as OpenBugs and Stan allow using easy-to-build modular likelihood models to fit models to data through MCMC or other techniques. Crucial to the efficiency of such tools, especially as parameter dimensions increase, are tools like HMC, which allow use differentiation and/or conjugacy for continuous parameters, so that fitting is not solely a matter of getting lucky with random Metropolis-Hastings proposals. Yet some models, especially nonparametric ones, also require discrete parameters and/or hand-written jump steps; and existing tools for HMC generally don't play well with discrete parameters. My project is intended to generally improve the Julia toolchain for MCMC when there is a mix of continuous and discrete parameters. My work will be based on Mamba.jl; though when I can make something that will be useful to Klara.jl too, even better. To make that plan concrete, I'll be implementing CrossCat, a general-purpose nonparametric model for "medium-size" tabular data including missingness and various data types. (Roughly speaking, "medium-size" might mean p&lt;1e3, n&lt;1e5).</p>

cjavascriptc+++12
Student: Jameson Quinn
Code

Enriching Model Zoo with Deep Learning Models

intermediate
The Julia Language•2019Varies175h (Medium)

<p>The aim of this project is to enrich Flux Model Zoo with unsupervised deep learning models, in particular variants of Generative Adversarial Networks. I propose to add the following models : 1) Spatial Transformer Networks 2) StarGAN for facial expression synthesis 3) VAE-GAN 4) Energy Based GAN 5) Gated Recurrent Convolutional Neural Network</p>

cjavascriptc+++12
Student: Manjunath Bhat
Code
Proposal

Enhance KomaMRI.jl GPU Support

advanced
The Julia Language•2024Varies350h (Large)

KomaMRI.jl is a Julia package for Magnetic Resonance Imaging (MRI) simulation focused on speed and extensibility. Like other MRI simulators, it solves the Bloch equations, for which the solution can be parallelized due to the independent spin property of the system. Although KomaMRI currently has built-in support for GPU and CPU parallelization, GPU support is CUDA-based and could be extended to work with different GPU backends. In addition, writing GPU kernels tailored for the solution implementation could significantly improve performance compared with the current array-based approach. The goals for this project are to update the KomaMRI.jl package to support Metal, AMD, and OneAPI-based GPU backends, and create a new BlochKernel simulation method which is fully kernel-based and optimized. If time permits, the use of MPI.jl and Distributed.jl to run MRI simulations across multiple nodes and GPUs will also be explored.

cjavascriptc+++12
Student: Ryan Kierulf
Code
Proposal

JuliaHealth's Tools for Patient-Level Predictions: Strengthening Capacity and Innovation

intermediate
The Julia Language•2023Varies175h (Medium)

Working with the OMOP CDM (Observational Medical Outcomes Partnership Common Data Model) involves handling large datasets that require a set of tools for extracting the necessary data efficiently. The first part of the project focuses on improving JuliaHealth's infrastructure by increasing the range of tools available to users. This involves enabling connections to various databases, and working with observational health data. Our second goal is to leverage the capacity built in the previous phase to develop a comprehensive framework for patient-level prediction. This framework will predict patient cohort outcomes with given treatments and will be tested on the mimic iii data, and potentially on real aggregated and anonymized patient data.

cjavascriptc+++12
Student: Fareeda Abdelazeez
Code

GraphBLAS Implementation

intermediate
The Julia Language•2019Varies175h (Medium)

<p>This project aims to get the GraphBLAS API working from Julia by connecting it to the SuiteSparse GraphBLAS implementation and creating a graph type backed by the methods provided in the library.</p>

cjavascriptc+++12
Student: Abhinav Mehndiratta
Code
Proposal

Parallelism in Bio.jl

intermediate
The Julia Language•2017Varies175h (Medium)

<p>Support parallelism in Bio.jl based on Dagger.jl</p>

cjavascriptc+++12
Student: Kenta Sato (bicycle1885)
Code
Proposal

Improving search functionality for Documenter.jl

advanced
The Julia Language•2025Varies350h (Large)

This project aims to significantly enhance the search experience within documentation generated by Documenter.jl. The current client-side search encounters difficulties accurately indexing and retrieving results for Julia-specific syntax, leading to suboptimal relevance. Furthermore, issues like unnecessarily large search indices and repeated listing of the same location hinder usability. This proposal outlines a plan to address these shortcomings by: 1) Implementing search performance benchmarks (relevance, precision/recall, index size) to measure and guide improvements. 2) Developing and integrating an improved, Julia-aware tokenizer within the search JavaScript. 3) Optimizing the index by investigating and removing redundant data, ensuring unique location entries are stored, and adding warnings for potentially problematic large indices. 4) Creating comprehensive developer documentation for the enhanced search system. The outcome will be a more robust, accurate, and efficient search capability for users navigating Julia package documentation.

cjavascriptc+++12
Student: Mohd Rahban Ghani
Code
Proposal

New Features for Flux.jl

beginner
The Julia Language•2017Varies90h (Small)

<p>Flux.jl is a high-level neural network library in Julia, which has an intuitive API, easy to debug, and performant. One of the key features of Flux.jl is that it allows user to define a layer in Julia, using most Julia Array operations, while not to worry about size inference, grad calculations, etc. Unlike Knet.jl, a promising competitor of Flux.jl, which do all the tensor calculations from scratch with a lot of magics, Flux.jl simply transcompile the computation graph to mature backends like MXNet and TensorFlow. Thus, it can take the benefits of those advanced technologies and get a cutting-edge performance.</p> <p>Flux.jl is in alpha and lacks a lot of features before being actually useful. One of the problems is currently it only supports SGD optimizer without decay and momentum. It also only shows the progress during training, while saving checkpoints or doing custom evaluations once a while can help users to build a better model.</p> <p>After this program finished, Flux.jl will be able to:</p> <ul> <li>train a model with most popular optimizers like Adagrad, Adam, etc.</li> <li>hook functions at specific time point, such as after every 100 batches</li> </ul>

cjavascriptc+++12
Student: Zhang Shiwei
Code
Proposal

An Alternative to Distributed for Pluto.jl

intermediate
The Julia Language•2022Varies175h (Medium)

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.

cjavascriptc+++12
Student: Sergio A. Vargas
Code
Proposal

Symbolic computation with Julia (Symbolics.jl): Symbolic Root finding

intermediate
The Julia Language•2024Varies175h (Medium)

Currently, Symbolics.jl has a Groebner basis implementation which is able to convert a myriad of symbolic expressions into multi-variate polynomials. This can be incredibly useful for solving functions for their roots, but to do so, a root finder for these generated polynomials must be implemented. Moreover, multiple users of Symbolics.jl have requested a symbolic nonlinear solver. As such, the project aims to complete the following: 1- Solve single variable polynomials (even high degree ones n ≥ 4) and multi-variable polynomials (over 2 dimensions or more) 2- Solve transcendental / other types of non-linear equations (highly requested: issues #961, #468, and #866) 3- Ensure that the implementation is well tested and well documented to make it more user-friendly and help out future contributors of the project.

cjavascriptc+++12
Student: Yassin ElBedwihy
Code

Sharing is Caring; Improving the Julia GPU Stack Portability.

advanced
The Julia Language•2025Varies350h (Large)

The state of Julia GPU support ranges from “very good” (CUDA.jl) to “on the way” (Metal.jl). Recently, the shared high-level interface GPUArrays.jl added support for KernelAbstractions.jl, which defines a common interface that can be used to write optimized kernel implementations once for all the downstream vendor-specific GPU packages such as CUDA.jl, AMDGPU.jl, Metal.jl, and oneAPI.jl. However, most optimized kernel implementations still live in the vendor-specific package they were written for, leaving the other packages to either reimplement their own version, use the current unoptimized fallback implementation from GPUArrays.jl, or in many cases, the operation is not supported. This project aims to rewrite these optimized operations in GPUArrays.jl using the KernelAbstractions interface to improve performance and functionality for all GPU backends at once. The end result being that users of the less mature backends will benefit from more functionality, as well as increasing the impact of future contributions for all users of the JuliaGPU ecosystem.

cjavascriptc+++12
Student: christiangnrd
Code

An Artificial Neural Network Differential Equation solver for Julia

beginner
The Julia Language•2017Varies90h (Small)

<p>The purpose of this project is to develop a flexible library of NN solvers (<strong>NeuralNetDiffEq.jl</strong>) which are able to utilize parallelization, and plugs into the <strong>DifferentialEquations.jl</strong> ecosystem giving user an easy option to switch to these methods. The problem to be solved and advantages of the proposed approach are discussed in the <strong>Introduction</strong> of the proposal. The library will implement as much of DE solver interface features we have in julia along with some integration with other related packages. The goals and timeline for the project are also discussed in the proposal. I have a single ODE solver as a prototype and code can be checked <a href="https://github.com/JuliaDiffEq/NeuralNetDiffEq.jl/blob/master/src/proto/DE-NN-Knet.jl" target="_blank">here</a>.</p>

cjavascriptc+++12
Student: Akshay Sharma
Code

Tight-Binding Atomic Graph Neural Networks

intermediate
The Julia Language•2021Varies175h (Medium)

<p>Virtually all properties of interest arise from electronic interactions between the atoms of a crystal.</p> <p>The work I propose aims to develop a physics-informed graph convolutional neural network architecture, inspired by the <a href="https://en.wikipedia.org/wiki/Tight_binding" target="_blank">Tight-Binding model</a> formalism. This would help us initialise weights with information from the Slater-Koster tables made available as a priori, which would theoretically help derive a more realistic, accurate and data-efficient representation.</p> <p>In addition to this, I also aim to help design and develop essential parts of <a href="https://github.com/Chemellia" target="_blank">Chemellia</a>; primarily <a href="https://github.com/Chemellia/ChemistryFeaturization.jl" target="_blank">ChemistryFeaturization.jl</a>.</p>

cjavascriptc+++12
Student: Anant Thazhemadam
Code
Proposal

Support for Optimization with Complex Variable in Convex.jl

advanced
The Julia Language•2016Varies350h (Large)

<p>Many problems in applied sciences are posed as convex optimization problems over the complex field such as MaxCut, Phase retrieval from sparse signals, designing a FIR filter given desired frequency response.</p> <p>The present approach is to manually convert the complex-domain problems to real-domain problems, then use domain specific languages like Convex.jl, cvx or cvxpy to get the solution of the corresponding real-domain problem and finally combine the solution from these languages to get the complex-domain solution. This process can be time-consuming and non-intuitive sometimes. The correct approach to such problems is to make our existing packages deal with complex-domain problems directly.</p> <p>The aim of the project is to add the support for solving complex-domain linear programs, second order conic programs as well as complex semidefinite programs (SDP) in Convex.jl (a Julia package for Disciplined Convex Programming).</p>

cjavascriptc+++12
Student: KrishnaKanhaiya
Code

Implementing a Graph-State Backend for QuantumClifford.jl

advanced
The Julia Language•2025Varies350h (Large)

QuantumClifford.jl enables efficient simulation of Clifford circuits acting on stabilizer states using the (de)stabilizer formalism, with complexity O(𝑛²), where 𝑛 is the number of qubits. For sparse stabilizer states—those with a qubit connectivity of O(log 𝑛)—an alternative algorithm based on graph states achieves improved complexity of O(𝑛 log 𝑛). This project aims to implement this graph-states-based simulator as an alternative backend in `QuantumClifford.jl`. Specifically, the project will: support the simulation of generator gates {𝐻, 𝑆, Λ𝑍}, enable the decomposition of arbitrary Clifford gates into these three generators, and implement single-qubit Pauli measurements on graph states. The goal is to provide a seamless transition to the graph-based simulator through compatibility with existing `apply!` and `project!` APIs in `QuantumClifford.jl`.

cjavascriptc+++12
Student: Kanyang Ying
Code

Empowering Julia-based Data Science with MLflow

intermediate
The Julia Language•2023Varies175h (Medium)

MLFlowClient.jl lacks of updates regarding new features coming from the original Python package. Some effort is needed to ensure new version methods. My plan is to implement that novel features using pure Julia, increasing compatibility; and also new functionality to allow communication with MLJ.

cjavascriptc+++12
Student: Jose Esparza
Code
Proposal
Showing 1177 - 1200 of 3883 Projects
4849505152
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal