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

Capsule Networks for 3D Medical Imaging Segmentation in Julia

advanced
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 →
350h (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
Proposal

Native Julia ODE, SDE, DAE, DDE, and (S)PDE Solvers

advanced
The Julia Language•2019Varies350h (Large)

<p>The <code>DifferentialEquations.jl</code> ecosystem has an extensive set of state-of-the-art methods for solving differential equations. By mixing native methods and wrapped methods under the same dispatch system, <code>DifferentialEquations.jl</code> serves both as a system to deploy and research the most modern efficient methodologies. While most of the basic methods have been developed and optimized, many newer methods need high performance implementations and real-world tests of their efficiency claims. In this project, students will be paired with current researchers in the discipline to get a handle on some of the latest techniques and build efficient implementations into the DiffEq ecosystem (<code>OrdinaryDiffEq.jl</code>, <code>StochasticDiffEq.jl</code>, <code>DAEDiffEq.jl</code>).</p>

cjavascriptc+++12
Student: Deepesh Thakur
Code

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

HTTP/2 Implementations for HTTPServer.jl, Requests.jl, and Mux.jl

intermediate
The Julia Language•2016Varies175h (Medium)

<p>This proposal is about implementing HTTP/2 for HTTPServer.jl and Requests.jl, as well as implementing a heuristic for Mux.jl for HTTP/2’s “server push”. In the end, It is expected that Mux.jl, HTTPServer.jl and Request.jl users can seamlessly transit to HTTP/2 with little changes on their sides.</p> <p>Here are some expected outcomes of this project.</p> <ol> <li>A new, unified version of the HTTPServer module and Requests module for both HTTP/1.1 and HTTP/2. The API "disables" certain methods and options for a HTTP/1.1 connection.</li> <li>Extensions such as Alternative Services and Opportunistic TLS will be implemented in HTTPServer.jl and Requests.jl.</li> <li>Specifically for HTTPServer.jl, expose a nice “server push” API that allows other libraries to specify what other resources to push along with the requested resources.</li> <li>In Mux.jl, build a middleware for HTML and CSS to extract resources to be “server pushed”. Good documentation and tests for those middlewares.</li> </ol>

cjavascriptc+++12
Student: Wei Tang
Code

Polychord Nested Sampling Algorithm Building and Integration with Turing in Julia

intermediate
The Julia Language•2020Varies175h (Medium)

<p>Polychord is a nested sampling algorithm which is designed to sample from high-dimensional parameter spaces. Slice sampling is used at each iteration to sample within the likelihood constraint of nested sampling. Polychord is capable of identifying various modes of the posterior. This project aims to construct a polychord nested sampling algorithm in Julia. The final integration will be built into Turing.</p>

cjavascriptc+++12
Student: Saranjeet Kaur Bhogal
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

Bringing in Novel Animation Abilities to Javis.jl

intermediate
The Julia Language•2022Varies175h (Medium)

My proposal is to bring in core changes to Javis' Object - Action mechanism for making animations . As of now Javis does not store drawing information as a data-structure but a function at compute time. The Object is drawn to the canvas by a function call at render time. The proposal has 3 parts. First - pre-compute the polygons/paths that an Object will place on the canvas, and have that information as a field in the Object. This part involves hacking into functions in Luxor.jl to store/return the information of drawn paths somewhere. Second - Bring in the ability to partially draw an object with the above paths at hand. Also implement functions to animate the "creation" of the object being shown. For example if the Object were a circle , the creation animation would draw an arc increasing its angle from 0 to 2Pi . Third - Bring in the ability to morph an Object into another. For example turn a square into a circle. The current implementation of Morphing in Javis has certain limitations, with the proposal implemented any arbitrary Object would be morph-able into another Object

cjavascriptc+++12
Student: John George Francis
Code

General partial differential equation solver using neural networks

intermediate
The Julia Language•2020Varies175h (Medium)

<p>Differential equations are widely used in any scientific field. A new method of solving differential equations using deep learning methods has great prospects and have greater versatility over the grid numerical methods. Neural networks can be used as a method for efficiently solving difficult partial differential equations(PDEs). The library that provides the method for solving a general form of PDEs using deep learning will be a useful tool for many scientists and engineers, as well as students.</p> <p>This project aims to design of a general solver for different types of PDEs using deep learning approach base on the <a href="https://arxiv.org/abs/1907.04502" title="PINNs" target="_blank">PINNs</a> algorithm as part of <a href="https://github.com/SciML/NeuralPDE.jl" title="NeuralPDE" target="_blank">NeuralPDE.jl</a> library using the <a href="https://github.com/JuliaDiffEq/ModelingToolkit.jl" title="ModelingToolkit" target="_blank">ModelingToolkit.jl</a> PDE interface.</p>

cjavascriptc+++12
Student: Kirill Zubov
Code

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

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

Integrating the Modern CFD Package Trixi.jl with Compiler-Based Auto-Diff via Enzyme.jl

advanced
The Julia Language•2024Varies350h (Large)

Trixi.jl is a numerical simulation framework for conservation laws written in Julia. The integration of Trixi.jl with Compiler-Based (LLVM level) automatic differentiation via Enzyme.jl offers the following benefits: facilitates rapid forward mode AD, enables reverse mode AD, supports cross-language AD, and critically, supports mutating operations and caching, on which Trixi.jl relies, to enhance the performance of both simulation runs and AD. The final deliverable will include as many of Trixi's advanced features as possible, such as adaptive mesh refinement, shock capturing, etc., showcasing the benefits of differentiable programming in Julia's ecosystem.

cjavascriptc+++12
Student: Junyi Xu
Code
Proposal

Allocation-Free GPU Adaptive Mesh Refinement for P4estMesh in Trixi.jl.

advanced
The Julia Language•2026Varies350h (Large)

My main goal this summer is to make Adaptive Mesh Refinement (AMR) fast and efficient for P4estMesh on GPUs within Trixi.jl. Right now, whenever the mesh adapts dynamically, it triggers repeated memory allocations on the device. This creates a severe host-device synchronization bottleneck that kills performance, despite the excellent hardware support we have via KernelAbstractions.jl. To solve this, I will build an allocation-free memory manager. By implementing a multi-pool arena specifically designed to match Trixi's Struct-of-Arrays (SoA) layout, I aim to eliminate these driver-level stalls. My final deliverables include a fully functional, type-stable GPU AMR pipeline and comprehensive performance benchmarks across both NVIDIA and AMD hardware

cjavascriptc+++12
Student: Shahu Karale
Code

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

Native Julia solvers for ordinary differential equations and improvements to IVP testing suite

advanced
The Julia Language•2016Varies350h (Large)

<p>ODE.jl is an ever increasing store house of numerical solvers of ordinary differential equations. While many solvers are currently found in ODE.jl, there are still many which are awaiting a native Julia implementation in the package. In particular, there is a lack of implicit solvers implemented in ODE.jl (currently, there is only one implicit solver: ode23s). Such solvers are important because they are especially suited for solving stiff ODEs, which are very common. In light of this, the first goal of my proposed project is a native implementation of implicit solvers RADAU and MEBDFI. Further, in order to reliably use ODE.jl, a robust initial value problem (IVP) testing suite for ODE.jl solvers is a necessity. Work has has been started towards this end through the development of IVPTestSuite.jl. Though, there are many improvements to IVPTestSuite.jl which could be made, especially in improving the ODE solver performance tracking. Thus, the second goal of my proposed project is to advance IVPTestSuite.jl and its surrounding documentation.</p>

cjavascriptc+++12
Student: obiajulu
Code

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

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

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

Middlewares for common web application chores

intermediate
The Julia Language•2017Varies175h (Medium)

<p>Implementation of mid-level features - specifically routing, load-balancing, cookie/session handling, and authentication.</p>

cjavascriptc+++12
Student: Sarvjeet Ghotra
Code
Proposal

Discontinuous Galerkin Infrastructure For the finite element toolbox Ferrite.jl

intermediate
The Julia Language•2023Varies175h (Medium)

This project aims to implement the necessary infrastructure for the Discontinuous Galerkin method in the finite element toolbox Ferrite.jl. This will include writing examples, documentation, and tests. DG method is a FEM like the continuous Galerkin (CG) method where the test functions are chosen to be the same as the trial functions. However, DG elements do not share degrees of freedom (DoF) at common nodes, introducing extra DoF and adding the process of choosing coupling between elements through numerical fluxes. The main deliverables are: • Methods to integrate on inner faces. • Extend the methods to integrate over subfaces. • Sparsity pattern methods for DG. • Implement infrastructure for handling boundary conditions for DG approximations. • 1-D, 2-D, and 3-D steady heat equation using DG example. • Testing and documentation for all implemented methods.

cjavascriptc+++12
Student: Abdulaziz Hamid
Code

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

Productive Scalable Distributed Task Scheduling Using an MPI-based Backend for Dagger

advanced
The Julia Language•2025Varies350h (Large)

This project extends Dagger.jl with an MPI-based backend, allowing it to scale more effectively on high-performance computing (HPC) clusters that use low-latency interconnects like Infiniband or HPE Slingshot. Dagger already offers a productive way to express parallelism in Julia, using Directed Acyclic Graphs (DAGs) to schedule and run tasks. However, it currently relies on Julia’s Distributed.jl and TCP for communication, which becomes a bottleneck at large scales. In the exaflop era, where extreme-scale simulations demand both scalability and productivity, this limitation is significant. By integrating MPI, we build on vendor-optimized communication libraries to combine Dagger’s ease of use with the performance needed in HPC environments, much like frameworks such as Legion and Iris.

cjavascriptc+++12
Student: Yan Guimarães
Code

Bringing state-of-the-art categorical variable encoding methods to Julia

beginner
The Julia Language•2024Varies90h (Small)

Bring the most recent classical and deep learning methods for categorical encoding to Julia to better support the presence of categorical variables in machine learning problems. This will at least include target encoding, entity embedding, potentially other methods and improvements on existing ones. The methods will be implemented in pure Julia and easy-to-use interfaces for them will be exposed to the community.

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

Documentation tools for Julia

beginner
The Julia Language•2016Varies90h (Small)

<p>A big part of Julia is its package ecosystem and their documentation should be as thorough as possible and documenting packages should be made as easy as possible for package developers.</p> <p>The primary goal of the project is to extend Documenter.jl so that it could also generate a detailed reference manual of functions, types, submodules etc. with full signatures and a search capability. The idea is to complement the docstring, since sometimes you need this detailed information and it should be easily accessible (reading the code or using introspection methods is cumbersome).</p> <p>A secondary goal is to lay the groundwork for a comments/notes system, where the community could more easily contribute to the docs (of both Base and packages).</p>

cjavascriptc+++12
Student: mortenpi
Code
Proposal
Showing 625 - 648 of 3179 Projects
2526272829
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal