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

Tight-Binding Atomic Graph Neural Networks

intermediate
The Julia Language•2021Varies

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 →
175h (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

FastAI.jl Development

advanced
The Julia Language•2021Varies350h (Large)

<p>Aim is to build all the portions of the FastAI.jl package, inspired by the fastai Python library, which will provide high-level components that can quickly and easily provide state-of-the-art results for tabular tasks, and provide low-level components that can be mixed and matched to build new approaches.</p> <p>This will include handling tabular data of all kinds of format, performing transformations on it if required, creating a model using best practices and entity embeddings, and being able to train the created model.</p> <p>All this will be done without compromising in ease of use, flexibility, or performance, due to the benefits Julia provides, along with the well designed three layered architecture.</p>

cjavascriptc+++12
Student: Manikya Bardhan
Code
Proposal

komamripy - Python Wrapper for KomaMRI

advanced
The Julia Language•2026Varies350h (Large)

KomaMRI.jl is a high-performance Julia package for MRI simulation and differentiable workflows, but its use is currently limited to the Julia ecosystem, creating a barrier for the broader Python-based scientific computing and machine learning community. This project introduces komamripy, a lightweight Python wrapper that exposes KomaMRI’s core simulation and differentiable capabilities through a minimal, intuitive API. The approach leverages Julia–Python interoperability to map data structures between environments, incorporates Julia-side precompilation to reduce first-use latency, and enables flexible GPU backend support across CUDA, AMDGPU, Metal, and oneAPI. The project will deliver a pip-installable Python package with CI-tested builds and automated releases, precompiled simulation and autodiff workflows, cross-platform GPU backend selection, and a validated end-to-end example demonstrating differentiable RF pulse optimization using JAX, along with supporting documentation and example scripts.

cjavascriptc+++12
Student: Anvika Singhal
Code
Proposal

Integrate the MuZero algorithm into the AlphaZero.jl package

intermediate
The Julia Language•2022$3k–$6.6k175h (Medium)

In March 2016, AlphaGo became the first computer Go program to beat one of the best go players in the world. But Deepmind didn’t stop there and kept developing better versions of it, namely: AlphaGo Zero, AlphaZero, and MuZero. AlphaZero.jl is an open-source implementation of one of those and became a great showcase of Julia’s unique strengths. And it is the 8th most starred Julia package. This Google Summer of Codes aims to add on top of AlphaZero, the MuZero implementation into AlphaZero.jl and create an interactive and pedagogical website that not only explains the MuZero algorithm but also illustrates deeper explanations of its hyperparameter tuning and implementation tradeoffs. This GSoC will not only expand a great Julia package but also give more visibility and illustrate Julia’s advantages in Machine Learning projects.

cjavascriptc+++12
Student: Guillaume THOMAS
Code

Molly.jl: Machine Learning Potentials for Molecular Dynamics

advanced
The Julia Language•2026Varies350h (Large)

Classical force fields in molecular dynamics are fast but cannot capture bond breaking, charge transfer, or complex many-body chemistry. Machine learning potentials (MLPs) close this gap — offering near-quantum accuracy at a fraction of ab initio cost. Molly.jl currently supports MLPs only through a Python bridge (ASECalculator), which requires a Python runtime and bypasses Julia's differentiable programming stack entirely. This project delivers native Julia support for four widely-used MLP families: ANI (neural network potential for organic molecules), ACE (linear body-ordered basis expansion), NequIP, and Allegro (E(3)-equivariant graph neural networks). ANI is implemented from scratch in pure Julia using Lux.jl, with pre-trained ANI-1x/ANI-2x weights loaded from HDF5. ACE is integrated via the mature ACEpotentials.jl package. NequIP and Allegro are wrapped from TorchScript-exported models via PythonCall, following the existing ASECalculator pattern. All four potentials plug into Molly.jl's general_inters dispatch loop with zero changes to core simulation code. Pure-Julia models (ANI, ACE) are fully differentiable via Enzyme reverse-mode AD and GPU-accelerated via KernelAbstractions. The result: researchers can run differentiable, ML-accelerated molecular dynamics entirely within Julia — no Python, no overhead, composable with the full SciML ecosystem.

cjavascriptc+++12
Student: Siva Sathyaseelan
Code

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

R Interface for JuliaBUGS

intermediate
The Julia Language•2025Varies175h (Medium)

The main goal of this project is to develop the R interface for JuliaBUGS, enabling a broader range of users already familiar with these languages to leverage the features of JuliaBUGS. This integration will not only facilitate the use of JuliaBUGS’ concise formulation alongside modern methods such as Hamiltonian Monte Carlo (HMC) and Automatic Differentiation (AD) but will also attract new users, helping to expand, consolidate, and strengthen the Julia community. The project will be under the umbrella project Turing.jl, and will have a duration of 175 hours.

cjavascriptc+++12
Student: Mateus Maia
Code
Proposal

Design of an API and set up of a regression tracker for iterative methods in Julia

advanced
The Julia Language•2016Varies350h (Large)

<p>This proposal consists of the design of an API for Iterative methods in Julia and the set up of benchmarks and a regression tracker.</p>

cjavascriptc+++12
Student: lopezm
Code
Proposal

Particle Swarm Optimization for Hyperparameter Tuning in MLJ

intermediate
The Julia Language•2021Varies175h (Medium)

<p>Machine learning models have demonstrably achieved significant success in data classification and prediction across innumerable industries and applications. Today, rolling out a new model has become ever easier with the popularization of open-source frameworks such as scikit-learn and MLJ. Despite the unprecedented accessibility, designing effective models with appropriate hyperparameters remains obscure for the common user without high-level technical understanding and expert intuition. In an effort to automate the process of tweaking hyperparameters, MLJ has introduced a unified interface for tuning models, providing support for widely used strategies like grid and random search. The available schemes, however, primarily perform exhaustive testings on selected hyperparameter combinations. In this proposal, I present a plan to implement a new strategy, particle swarm optimization (PSO), which utilizes information from past attempts to improve hyperparameter search. The first section offers a summary of the method and existing implementations, while the second sketches the technical details of a PSO algorithm for MLJ and a tentative timeline to deliver the project’s goals.</p>

cjavascriptc+++12
Student: Huu Long Nguyen
Code

Plug and Play Language Models in Julia

intermediate
The Julia Language•2021Varies175h (Medium)

<p>While pre-trained language models like GPT-2 provided with <a href="https://github.com/chengchingwen/Transformers.jl" target="_blank">Transformers.jl</a> can generate coherent text, controlling and steering of text towards the desired attribute is not directly possible with these pre-trained models as it is (particularly without fine-tuning). So the goal of this project to implement <a href="https://github.com/uber-research/PPLM" target="_blank">Plug and Play Language Model</a> in Julia Language, which will facilitate the users working with Julia for NLP to generate Controllable text based on Transformers.jl package, which can be used in deployable Chatbots and further research in the field of Text Generation with Julia. Apart from the model, the final product of this project will also include an end-user interface to facilitate the integration of the PPLM model with few lines of code.</p> <p>Some of the common applications of the model will include Sentiment Control and detoxification of the generated text.</p>

cjavascriptc+++12
Student: Adarsh Kumar
Code
Proposal

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

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

Query.jl to SQL translation

intermediate
The Julia Language•2019Varies175h (Medium)

<p>I want to write code to translate the syntax supported by Query.jl into SQL. Then, the queries can be sent to a variety of database softwares. I can take inspiration from implementations in other programming languages (notably LINQ). This work will benefit any user who works with tabular data in Julia. The process to translate code to work optimally with columns might overlap with the process of translating code into SQL. If I am successful translating to SQL code, I will start working on column-based optimizations afterwards</p>

cjavascriptc+++12
Student: Brandon Taylor
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

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

GPU Acceleration for PDE Discretization in Trixi.jl using CUDA

beginner
The Julia Language•2023Varies90h (Small)

GPU computing provides substantial performance gains over CPU-based methods for computationally demanding tasks. Trixi.jl, a Julia numerical simulation framework for hyperbolic conservation laws, currently lacks native GPU support. This project aims to accelerate PDE discretization in Trixi.jl using GPUs via CUDA. Key subtasks include developing a simple 1D CPU code, extending it to 2D and 3D, porting it to GPUs, prototyping GPU implementations of existing Trixi.jl kernels, optimizing data transfer, and expanding GPU support for more complex methods and GPU types. The final deliverable will offer high-performance PDE solvers on GPUs, showcasing the benefits of GPU acceleration in Trixi.jl.

cjavascriptc+++12
Student: Huiyu Xie
Code
Proposal

Differentiable Duckietown

intermediate
The Julia Language•2019Varies175h (Medium)

<p>Julia language offers support for differentiable programming with the help of its AD. This projects leverages this to test differentiable programming (DP) approach for autonomous vehicle research. Goal of the project is to create a duckietown environment in julia and have it trained with DP algorithms on various maps.</p>

cjavascriptc+++12
Student: Tejan Karmali
Code
Proposal

Implementation of a Reservoir Computing library for timeseries prediction

beginner
The Julia Language•2020Varies90h (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

A Generalized RAG-LLM Workflow Support Tool for JuliaHealth

advanced
The Julia Language•2026Varies350h (Large)

This project addresses the challenge of unreliable LLM outputs in complex health informatics workflows by building a domain-grounded Retrieval-Augmented Generation (RAG) system within JuliaHealth. It enables users to convert natural language queries into accurate, executable FunSQL.jl workflows by grounding responses in curated resources like OMOP and OHDSI. The project will deliver a modular baseline RAG pipeline, a reproducible evaluation framework to benchmark query quality, and clear documentation with an end-to-end demonstration for usability and future extension.

cjavascriptc+++12
Student: Param Thakkar
Code
Proposal

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

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

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

Reachability with sparse polynomial zonotopes

advanced
The Julia Language•2022Varies350h (Large)

Reachability analysis deals with uncertainty propagation in dynamical systems. Given an initial set, modeling the uncertainty on the initial state, it aims to answer the question "What is the set containing all possible final states?" This question is relevant in several domains such as safety-critical applications and systems verification. Traditional approaches have mainly concentrated to convex sets, which can lead to overestimation of the final state when this is actually non-convex (so-called wrapping effect). Recently, Sparse Polynomial Zonotopes (SPZ) have been introduced as a set representation for both convex and non-convex sets. SPZ have been shown to have a compact representation that allows efficient manipulation. The goal of this project is to implement Sparse Polynomial Zonotopes in LazySets.jl and the corresponding reachability algorithms in ReachabilityAnalysis.jl for the JuliaReach organization. The final result will be a state-of-the-art (SOTA) toolbox for reachability analysis with sparse polynomial zonotopes, together with systematic benchmarks comparing our Julia implementation both to different implementations of the same approach and other SOTA approaches in reachability analysis.

cjavascriptc+++12
Student: Luca Ferranti
Code
Proposal

Towards Better Images.jl Ecosystem

intermediate
The Julia Language•2019Varies175h (Medium)

<p>This project aims to achieve a better ecosystem for <code>Images.jl</code>, an image-processing toolbox in Julia. Main contributions consist of user-friendly documentation on <code>Images.jl</code> ecosystem, developer manual, and more consistent, robust, and extensible APIs. Moreover, this project also serves as a subproject to bring <code>Images.jl</code> from pre-Julia-1.0 stage to post-Julia-1.0 stage, and eventually to <code>Images.jl v1.0</code> milestone.</p>

cjavascriptc+++12
Student: Johnny Chen
Code
Proposal
Showing 1225 - 1248 of 3883 Projects
5051525354
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal