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

Learning from Imbalanced Data with Julia

intermediate
The Julia Language•2023Varies

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)

The objective of this project is to implement a class imbalance package in Julia with algorithms to correct for class imbalance. The package is expected to integrate well with other packages such as MLJ and to provide any useful resampling algorithms to handle the imbalance issue.

cjavascriptc+++12
Student: Essam Wisam
Code
Proposal

Tensor network contraction order optimization and visualization

advanced
The Julia Language•2024Varies350h (Large)

This project aims to further enhance the performance and usability of tensor network tools in Julia. There are three main goals of the project: 1) extending the optimization methods in OMEinsumContractionOrders.jl with the state of art contraction order optimization algorithms; 2) implementing a hyper-graph visualization tool for tensor networks as a standalone package; 3) porting the contraction order optimization algorithms in OMEinsumContractionOrders.jl to the TensorOperations.jl package as a backend. Testing and documentation will also be done for all implemented methods, and the code will be open-sourced and published to the Julia community.

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

FlashFill Implementation in Julia

beginner
The Julia Language•2022Varies90h (Small)

FlashFill is a program synthesis framework for generating string-processing programs from input-output examples. This project aims to implement FlashFill in Julia and integrate it with DataFrames.jl. Such a package would be a valuable tool for Julia users handling tabular data, providing an easy way for data-cleaning and data-wrangling. It would also lay the foundations for implementations of further open-source program synthesis frameworks in Julia.

cjavascriptc+++12
Student: Atharv Sonwane
Code
Proposal

Language Interoperability - CxxWrap.jl

intermediate
The Julia Language•2024Varies175h (Medium)

The CxxWrap.jl package acts as a bridge between Julia and compiled C++ code, resulting in developers being able to use the best of both languages. While it already exposes a subset of the C++ standard library to Julia, there is a significant opportunity to expand its capabilities and enhance the interoperability further. The primary objective of this project is to improve the coverage of the C++ Standard Template Library within CxxWrap.jl. The STL is very widely used and provides a rich set of container types, algorithms, and utilities in C++.

cjavascriptc+++12
Student: PraneethJain
Code
Proposal

Redesigning GridWorlds.jl

beginner
The Julia Language•2021Varies90h (Small)

<p>Environments are a crucial component of <a href="https://en.wikipedia.org/wiki/Reinforcement_learning" target="_blank">reinforcement learning (RL)</a>. Grid worlds are a broad class of tile-based games that are easy to create, and are quite popular for testing and comparing various RL algorithms. They are highly versatile and provide immense flexibility in terms of creating custom environments that can test for specific properties like safe exploration, for example. <a href="https://github.com/JuliaReinforcementLearning/GridWorlds.jl" target="_blank">GridWorlds.jl</a> is a <a href="https://julialang.org/" target="_blank">Julia</a> package that provides a suite of grid world environments along with useful primitives that aid in creating custom environments.</p> <p>This project redesigns GridWorlds.jl in a way that makes it simpler, easy to understand, and more performant (in some cases) than the previous version (v0.4.0). The new version (v0.5.0) also decouples itself significantly from the API of <a href="https://github.com/JuliaReinforcementLearning/ReinforcementLearning.jl" target="_blank">ReinforcementLearning.jl</a>, which makes it easy to create entry points from other reinforcement learning frameworks. It also becomes possible to programmatically record, replay, and analyze an agent’s behavior at any point during training, which proves handy while performing reinforcement learning experiments. Moreover, one can directly play the games from GridWorlds.jl inside the Julia REPL.</p>

cjavascriptc+++12
Student: Siddharth Bhatia
Code
Proposal

Developing Tooling for Observational Health Research in Julia

intermediate
The Julia Language•2024Varies175h (Medium)

As a part of this project, I will be working with JuliaHealth to develop the OMOPCDMPathways package for health and medical data analysis. The package will include features such as selecting treatments of interest, finding treatment history of patients, combining overlapping events, filtering treatments for repeated occurrences, and examining drug refills. And as a part of stretch goals I also aim to integrate with the JuliaStats ecosystem and create novel visualizations for treatment pathways. My project timeline is designed for a structured and comprehensive development process. I'll begin by setting up my development environment and database connections, then move on to selecting treatments of interest and preparing the database. Following that, I'll work on filtering treatments for repeated cohorts, developing the treatment history of patients, handling drug refills, and era collapse, with each task having its own dedicated time for development and testing.

cjavascriptc+++12
Student: Jay Sanjay Landge
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

JuliaGPU: Improving GPU stack portability in JuliaGPU

advanced
The Julia Language•2026Varies350h (Large)

The Julia GPU ecosystem allows users to write array programs that run seamlessly across NVIDIA, AMD, and Intel GPUs. This functional portability relies on GPUArrays.jl, which defines the common interface implemented by all vendor packages. However, several foundational operations currently lack shared implementations. Operations such as reverse, findall, accumulate!, and mapreduce either crash on backends lacking a vendor override or silently degrade to CPU execution by copying data back and forth. A direct source audit of GPUArrays.jl (v11.4.1), CUDA.jl, AMDGPU.jl, oneAPI.jl, and Metal.jl confirmed these gaps: reverse and findall are entirely absent from the shared fallback layer, accumulate! exists only as a scalar CPU fallback, and mapreducedim! is declared as an error("Not implemented") stub, forcing every backend to maintain isolated, vendor-specific implementations. This project resolves these portability gaps by establishing a cleaner, more robust architecture: moving critical GPU kernels upstream to AcceleratedKernels.jl (AK.jl) while refining GPUArrays.jl into a lightweight, pure delegation layer. Building upon the newly introduced KernelIntrinsics API, this approach implements highly optimized, vendor-neutral kernels directly within AK.jl. Because Julia’s multiple dispatch inherently prefers the most specific method, routing AnyGPUArray fallbacks to AK.jl means backends with existing optimized vendor methods remain untouched, while backends missing the functionality automatically receive high-performance GPU execution instead of a crash or silent slowdown.

cjavascriptc+++12
Student: Shreyas Hegde
Code

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

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

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

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

Performance Enhancements and Optimizations for Differential Equation solvers

advanced
The Julia Language•2020Varies350h (Large)

<p>DifferentialEquations.jl comprises of leading-edge methods for solving Differential Equations and an extensive benchmark suite written purely in Julia. Many methods have state-of-the-art performances, but still, some of them can be accelerated for high-performance returns. This project aims to maintain the same standards and improve benchmark performances of various solvers. In essence, the project will emphasize increasing the speed through iterative optimizations, bug fixes and improvements, reduce redundant memory allocation and improved benchmarking.</p>

cjavascriptc+++12
Student: Utkarsh .
Code
Proposal

Implementing GPU Multi-Stream Capabilities to Dagger.jl

intermediate
The Julia Language•2026Varies175h (Medium)

Dagger.jl currently serializes all GPU tasks onto a single stream per device, leaving independent DAG branches unable to run concurrently and GPU hardware severely underutilized. This project implements multi-stream execution for the CUDA and ROCm backends by replacing the single fixed stream with a per-device stream pool, integrating stream-aware scheduling into the task dispatch layer, and replacing the global device barrier with event-based synchronization. The expected outcome is a significant reduction in end-to-end latency, improved Streaming Multiprocessor occupancy, and meaningful overlap between memory transfers and kernel execution.

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

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

Development of a New Language Server for Julia

intermediate
The Julia Language•2025Varies175h (Medium)

The Language Server Protocol (LSP) is a communication protocol between editors and analysis engines. Many major editors support this protocol, making Language Servers—development support tools that communicate with editors via LSP—highly significant in modern development environments. In this proposal, I aim to implement and enhance some new features for a new Language Server called JETLS, which is deeply integrated with the latest Julia compiler infrastructure. I will strive to deliver low-latency, precisely source-mapped feedback to users, enhancing the overall development experience by leveraging JET.jl, Revise.jl, JuliaSyntax.jl, and JuliaLowering.jl. JETLS will provide powerful editor support for programmers working on large-scale Julia codebases, helping them discover potential bugs and write more efficient code.

cjavascriptc+++12
Student: Yuchi Yamaguchi
Code
Proposal

Bringing GPU programming to DFTK.jl

intermediate
The Julia Language•2022Varies175h (Medium)

Density functional theory (DFT) is an established method to compute the electronic structure of matter, with applications ranging from the development of catalysts to the discovery of new drugs. DFT finds an approximation of the Schrödinger equation corresponding to the studied system: this approximation comes to solving coupled non-linear partial differential equations. To deal with this method of simulation, the DFTK package is being developed in Julia. To reduce runtime, we wish to develop the use of a local GPU to offload computations. However, the goal is to minimize the amount of code which needs to be adapted: having two different versions of the code existing at the same time (one for CPU and one for GPU) can be difficult to maintain in an open-source framework. This also makes the implementation of new algorithms difficult, and can deter newcomers from getting involved in the project. Since GPU algorithms for DFT already exist, the main challenge is to orchestrate the overall flow of data between CPU and GPU. We believe expanding the DFTK package will showcase the possibilities the Julia programming language offers and bring together many different communities involved in molecular simulation. I aim to produce an alternate version of code of the DFTK package using GPU framework by clearly highlighting the differences with the CPU version and keeping code changes as low as possible.

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

Rebuilding Interact.jl with WebIO.jl

advanced
The Julia Language•2017Varies350h (Large)

<p>Interactive data exploration is an increasingly important component of data science. Interact.jl and Escher.jl are good libraries that have the potential to be extremely powerful for these tasks, but currently Interact only supports IJulia and Escher suffers some stability issues. WebIO.jl looks to be a promising path forward for building web based components that are created by or interface with Julia. Rebuilding Interact.jl on top of WebIO.jl will bring Interact beyond IJulia, to the Atom/Juno IDE and to desktop apps with Electron/Blink.jl. Additionally it should enable Escher.jl to reuse much of Interact, which will likely reduce Escher’s size and complexity significantly, increasing its stability. Furthermore, by removing its dependence on Jupyter and IPywidgets, Interact will gain flexibility to produce more complex UIs which intermix displayed data such as plots, and UI controls. Finally, I plan to add some automated UI testing which hopefully will assist in improving the stability of not just Interact and Escher, but potentially IJulia, Juno, and Blink as well.</p>

cjavascriptc+++12
Student: Joel Mason
Code
Proposal

Rejuvenating Documenter

beginner
The Julia Language•2019Varies90h (Small)

<p>Documentation, essential for any software project, needs to be as easy as possible to write and publish. For Julia packages, you can use the <a href="https://github.com/JuliaDocs/Documenter.jl" target="_blank">Documenter package</a>, which automatically generates and publishes package manuals as a web page or a PDF.</p> <p>It is important for Documenter to be modern and flexible. This project aims to revitalize Documenter, by upgrading the generated HTML front end and making it easier for documentation authors to customize. This will make sure that Documenter will keep meeting the needs of the community for years to come.</p>

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

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
Showing 649 - 672 of 3179 Projects
2627282930
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal