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
3179 Projects Found
Sort by

Differentiable GPU-accelerated MRI Simulations

beginner
The Julia Language•2026Varies

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)

Advanced magnetic resonance imaging techniques, such as RF pulse optimization, increasingly rely on complex, high-performance physical simulations like those defined in KomaMRI.jl. Currently, integrating these simulations into optimization loops is bottlenecked by the lack of native gradient propagation. This project aims to unlock gradient-based optimization within the Koma ecosystem by enabling reverse-mode automatic differentiation (AD) as a first-class feature. By systematically integrating state-of-the-art AD tools, specifically Enzyme.jl and Reactant.jl, this project will make both the standard BlochSimple method and the highly optimized, custom Bloch GPU kernels fully differentiable. Core deliverables include establishing AD correctness baselines against FiniteDifferences.jl, designing a memory-efficient Simulation data structure to minimize device-host transfers, and resolving low-level upstream compatibility issues with CUDA.jl and Enzyme. Ultimately, this project will provide the Julia MRI community with a robust, fully differentiable simulation stack, culminating in an interactive tutorial for 1D RF pulse optimization.

cjavascriptc+++12
Student: Kareem Fareed
Code
Proposal

Supercharging the Knowledge Base of AIHelpMe.jl

intermediate
The Julia Language•2024Varies175h (Medium)

Traditionally if a user asks a question to an LLM about a package then, the response might be incorrect, or outdated. The project "Supercharging the Knowledge Base of AIHelpMe.jl" is about extending AIHelpMe’s knowledge base and build a RAG system to include the latest information about its documentation and to increase the accuracy of LLM’s response. Incorporating comprehensive, up-to-date Julia’s resources into the AI’s knowledge base will benefit Julia developers, programmers, AI and ML enthusiasts, or any programmer to get more accurate responses, clear doubts and solve bugs.

cjavascriptc+++12
Student: Shreyas Agrawal
Code
Proposal

Survey.jl

advanced
The Julia Language•2022Varies350h (Large)

This project adds a new package to JuliaStats, covering complex survey analysis. The package is inspired by the `survey` package in R. Specifically, a part of the R package is ported to Julia. The completed project will consist of added support for survey analysis, along with the associated documentation.

cjavascriptc+++12
Student: Iulia Dumitru
Code
Proposal

Capsule Networks for 3D Medical Imaging Segmentation in Julia

advanced
The Julia Language•2026Varies350h (Large)

Julia's medical imaging stack currently relies on 3D U-Net variants for segmentation, which lose spatial relationships through max-pooling. This project implements 3D capsule network architectures in Lux.jl that preserve part-whole spatial hierarchies through dynamic routing-by-agreement. I will build reusable capsule layer primitives (PrimaryCapsule3D, ConvCapsule3D, routing modules), two full architectures (3D SegCaps and a SegCaps-UNet hybrid), and custom GPU-accelerated routing kernels using KernelAbstractions.jl. The full pipeline integrates with MedPipe3D.jl for data loading, training, and evaluation. Deliverables: (1) Capsule layer primitives as Lux.jl modules, (2) 3D SegCaps architecture, (3) SegCaps-UNet hybrid, (4) GPU routing kernels, (5) training pipeline with MedPipe3D.jl, (6) benchmarks across all 10 Medical Segmentation Decathlon tasks (Dice, HD95, cross-task transfer vs 3D U-Net), (7) documentation and pretrained weights, (8) PRs to JuliaHealth.

cjavascriptc+++12
Student: Bhavya-QuantDeveloper
Code

Graph Neural Networks - Training on very large graphs

intermediate
The Julia Language•2024Varies175h (Medium)

Ever-growing size of social interactions, especially via on-line channels, creates a need for processing big datasets in an efficient way. Thanks to the verbosity level of Python combines with C speed Julia is a perfect tool to implement large graph processing algorithms. The purpose of this project is to enrich GraphNeuralNetworks.jl library with algorithms for processing large graphs based on the literature. First part of the project will focus on adding GraphSAGE in basic version and its variations (e.g. PinSAGE and UberEats inspired), including different sampling techniques and variety of aggregation operators. Then, less conventional approaches will be implemented, such as Cluster-GCN and algorithms based on linear algebra optimization. Finally, the project will be completed by creating tutorials for the new features.

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

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

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

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

Adding functionalities to medical imaging visualizations

intermediate
The Julia Language•2024Varies175h (Medium)

MedEye3D.jl aims to enhance medical imaging visualization within the Julia language ecosystem. The current proposal addresses the need for improved functionality in windowing, support for the display of super voxels, faster load times, and robust viewing of multiple images. By leveraging Rocket.jl and ModernGL.jl, the proposal plans to implement features like enhanced windowing for MRI and PET data, support for the display of super voxels, and high-level functions for improved user experience. The project aims to streamline visualization processes and provide essential tools for 3D medical imaging workflows. The main deliverables include: Supporting simultaneous visualization of multiple registered medical images, with linked scrolling, cursor highlighting, and connecting lines between annotated points across images. Implementing automatic windowing and colormaps for common MRI and PET imaging modalities to provide consistent visualizations mimicking other medical imaging software. Adding support for visualizing supervoxel segmentations with boundary detection using techniques like the Sobel filter. Improving startup time by precompiling critical components of the package. Implementing high-level functions to simplify basic usage by abstracting away low-level details of image loading, rendering, and visualization. By enhancing MedEye3D.jl with these features, the project aims to provide a more comprehensive and user-friendly tool for 3D medical image visualization and analysis within the Julia ecosystem. The improvements will facilitate better integration into medical imaging workflows and enable more efficient exploration and interpretation of data across different modalities.

cjavascriptc+++12
Student: Divyansh Goyal
Code

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

Image Segmentation

intermediate
The Julia Language•2017Varies175h (Medium)

<p>Image Segmentation is described as one of the most important aspects of image processing. Image segmentation is the process of partitioning an image by essentially assigning every pixel to a specific set based on the properties of this pixel and its neighborhood and henceforth dividing the image into segments and getting a more meaningful representation of the image. It is generally used to detect boundaries and high-level features and as a preprocessing step for compression and object detection algorithms which are impractical if applied directly on the whole image. The proposal primarily concerns implementing many of the popular image segmentation algorithms in pure Julia in the existing module <code>ImageFeatures.jl</code> (or a new module). A proper documentation and a few tutorials showing the usage of these algorithms shall also be developed.</p>

cjavascriptc+++12
Student: Animesh Kashyap
Code
Proposal

A Digital Twin approach for Advanced Supervoxel Visualization for Multi-Image View in Imaging

beginner
The Julia Language•2025Varies90h (Small)

This project extends the capabilities of the MedEye3D framework by developing an advanced visualization tool for supervoxel-based comparison across multiple medical imaging modalities (e.g., CT and MRI). The tool will enable users to interactively explore supervoxels on synchronized image views, with automatic highlighting of corresponding regions to aid in non-rigid registration and comparative analysis. Features include side-by-side image displays, interactive correction of supervoxel associations, and annotation of anatomical control points to support image alignment. Built using Julia, ModernGL.jl, and ITK/SimpleITK, this tool will enhance clinical workflows and research by improving registration accuracy and facilitating reliable visualization in complex imaging scenarios. The project contributes to digital twin applications in healthcare by enabling robust, user-guided multi-modality analysis.

cjavascriptc+++12
Student: Divyansh-Goyal
Code

Native Julia implementations of iterative solvers for numerical linear algebra

intermediate
The Julia Language•2017Varies175h (Medium)

<p>The IterativeSolvers.jl package is currently lacking some well-known iterative methods such as QMR and BiCGStab(l) for solving <em>linear systems</em> and IRAM and Jacobi-Davidson for <em>eigenvalue problems</em>. The first two methods are probably the last low-hanging fruit type of algorithms, while the latter two are quite specialized.</p> <p>Implementing Jacobi-Davidson and IRAM is important, since currently Lanczos is the only eigensolver available, which applies to hermitian matrices only. Jacobi-Davidson and IRAM are quite subtle to implement correctly and efficiently (they require specialized restarts for instance), which probably explains why they are currently not yet available.</p> <p>A benefit of having implicit restart available is that it can improve restarted GMRES as well.</p>

cjavascriptc+++12
Student: Harmen Stoppels
Code

Improving Turing’s documentation and tutorials

intermediate
The Julia Language•2021Varies175h (Medium)

<p>I would like to extend and update Turing’s documentation and include novel examples that show how to best use Turing’s capabilities in an applied setting.</p>

cjavascriptc+++12
Student: leachim
Code
Proposal

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

ZXCalculus.jl: ZX-calculus for Julia

advanced
The Julia Language•2020Varies350h (Large)

<p><a href="http://zxcalculus.com" target="_blank">ZX-calculus</a> is a graphical language that can characterize quantum circuits. It is a powerful tool that is usually used for quantum circuit simplification. <code>ZXCalculus.jl</code> will implement quantum circuit simplification algorithms based on ZX-calculus in pure Julia. Also, it will provide interfaces to import and export quantum circuits to the form of YaoIR, an intermediate representation for quantum programs in the <a href="https://github.com/QuantumBFS/Yao.jl" target="_blank"><code>Yao.jl</code></a>. So that one can get quantum circuits with higher performance automatically when designing quantum programs with <code>Yao.jl</code>.</p>

cjavascriptc+++12
Student: Chen Zhao
Code
Proposal

Improved ImageIO: adding JPEG2000, GIF, and EXIF support

intermediate
The Julia Language•2022Varies175h (Medium)

JuliaImages takes support from JuliaIO to provide encode and decode methods of various image formats. The focus of this project is to add IO support for GIF and JPEG2000 formats. This project also aims to provide improved metadata EXIF support for the Julia community.

cjavascriptc+++12
Student: Ashwani Rathee
Code
Proposal

Implementing Scalable Bayesian Optimization in Julia

intermediate
The Julia Language•2023Varies175h (Medium)

The main task of this project is to implement a modern Bayesian optimization method TuRBO in Julia, extending BayesianOptimization.jl package. The implementation will be based on paper [1]. It will be well tested, documented and integrated into the above mentioned package. The Julia ecosystem and open source community will benefit from this project in various ways since solvers are a key technology used by many methods from the applied sciences. For instance, as mentioned in [1], Bayesian optimization can be used for hyperparameter tuning in machine learning, calibrating a simulator to real world data, chemical engineering and materials discovery and many others. [1] David Eriksson, Michael Pearce, Jacob Gardner, Ryan D Turner, and Matthias Poloczek. Scalable global optimization via local bayesian optimization, 2019

cjavascriptc+++12
Student: Samuel Belko
Code
Proposal

Improving performance using sparse linear algebra

advanced
The Julia Language•2026Varies350h (Large)

Graph Neural Networks (GNNs) rely on message passing, traditionally implemented via a gather/scatter mechanism. In GraphNeuralNetworks.jl, this approach materializes dense feature matrices on graph edges, leading to severe memory bottlenecks and reduced performance as graph sizes scale. This project addresses this limitation by redefining message passing as non-materializing Sparse Matrix-Matrix Multiplications (SpMM). By treating the graph as a sparse mathematical operator, this project will unlock significant computational efficiency and memory savings on CUDA GPUs. The core objectives include integrating COO storage, upstreaming patches to CUDA.jl, and refactoring the GNNlib API. To ensure continuous momentum during upstream review cycles, the project features a secondary track focused on upgrading the Automatic Differentiation (AD) pipeline by fully integrating Mooncake.jl and Enzyme.jl, alongside expanding the ecosystem with new datasets and new tutorials / improved documentation.

cjavascriptc+++12
Student: Parv Mittal
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

Julia Symbolics Algebra Simplification and Equation Solving

advanced
The Julia Language•2022Varies350h (Large)

Implementation of algebraic simplification to reduce expression to canonical form. Low level rules are be hard coded for improved performance and higher level rules based on pattern matching. Algebraic solver to solve an equation or sets of equation by looping over a set of reversal rules until no further rules change the equation. The possibility of a Symbolic Integration Implementation based somewhat on Rubi Integration.

cjavascriptc+++12
Student: BlankBuffer
Code
Proposal

Development of Attractors.jl

intermediate
The Julia Language•2023Varies175h (Medium)

The main aim of this project is to expand the capabilities of Attractors.jl. We are specifically targeting three features, which are the Minimal Fatal Shock Algorithm, Automatic Attractor Characterization, and Optimizations of the recurrence algorithm. To be more specific, these three features encompass the following aspects: a novel algorithm for predicting the behavior of arbitrary systems under critical conditions, optimization, and improvement and optimization of the existing algorithms to expand their functionality and cover the weak points. We are confident that incorporating these new features will result in substantial improvements of the Attractors.jl library and will be highly valued by the nonlinear dynamics community in Julia.

cjavascriptc+++12
Student: Stefan Vayl
Code
Proposal

Introducing a implementation of distributed arrays and linear algebra routines for Dagger.jl

advanced
The Julia Language•2023Varies350h (Large)

This proposal intends to implement a distributed array for the Dagger.jl package, loosely inspired on DistributedArrays.jl and improving on the current baseline implementation of the Dagger.jl distributed array object, possibly via a complete overhaul, including support for the MPI subpackage, as well as known factorization algorithms and schemes such as QR, LQ, LU with partial pivoting, and SVD. The basic array operations will take as a basis the Basic Linear Algebra Subprograms, using julia native implementations. The main products of this will be a basic but very functional and helpful set of distributed operations for high performance algebra and array manipulations in conjunction with the finished implementation for the MPI subpackage of Dagger.jl.

cjavascriptc+++12
Student: Felipe Tomé
Code
Showing 697 - 720 of 3179 Projects
2829303132
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal