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

Improving performance using sparse linear algebra

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)

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

Development of a Modular and Composable Variational Inference and Normalizing Flow Library for Julia

intermediate
The Julia Language•2023Varies175h (Medium)

We propose to create a modular and composable library for variational inference and normalizing flow methods that emphasizes GPU compatibility and seamless integration with the Julia autograd ecosystem. The goal is to develop a user-friendly library that allows researchers and practitioners to easily construct and combine various components for variational approximation of general target distributions, without being tied to specific probabilistic programming frameworks or applications. Turing.jl's Bijectors.jl package offers an outstanding interface for working with normalizing flows; our project will build upon the foundation of Bijectors.jl to further enhance its capabilities and applicability. However, the current design of Bijectors.jl has several limitations such as lack of full GPU compatibility, lack of batch support, etc. Thefore, the main tasks of our projects are to address these limitations for Bijectors.jl, as well as developing the variational inference library.

cjavascriptc+++12
Student: Zuheng (David) Xu
Code

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

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

OptiFloat.jl: Automatic Floating Point Expression Optimization in Pure Julia

advanced
The Julia Language•2024Varies350h (Large)

Most scientific and engineering applications heavily depend on floating point arithmetic. Floating point numbers only approximate the real numbers, which can lead to accumulation of errors and ultimately to unusable results. Current state of the art of floating point arithmetic optimization is done in Rust (egg) or Racket (Herbie). This is not very accessible for the actual target group of scientists & engineers who are used to program in high-level languages such as Python, MATLAB and Julia. Additionally, it requires manual labour (rewriting symbolic expressions, then optimizing them, and finally translating the resulting code back to the original language) due to the necessity of interfaces to interoperate between different systems written in different languages. We propose to take advantage of Julia's homoiconicity and powerful existing symbolic-numeric ecosystem to implement an automatic floating point expression optimizer in Julia, acting on any expression that supports TermInterface.jl, such as Symbolics.jl expressions as well as native Julia code. The project will include a package that implements the floating point expression optimization apporach (OptiFloat.jl). To achieve this Metatheory.jl will be fully integrated with Symbolics.jl, enabling e-graph based optimization of any symbolic expression (not just numerical). Additionally we will finalize the release of Metatheory.jl v3.0, identify existing Julia packages that may suffer from numerical error propagation, and perform a thorough comparison of automatically optimized expressions vs. original vs. external system including the time required to obtain them.

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

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

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

Interactive Tutorial System for Julia and Juno

intermediate
The Julia Language•2016Varies175h (Medium)

<p>A Julia program for completing interactive tutorials, being available in the REPL and in Juno (in it’s current form as a series of Atom plugins), with a webpage interface as a stretch goal. Paired with this would be a tool for creating these lessons, and as another stretch goal some kind of central repository from which students can download tutorials and to which tutorial creators can upload.</p>

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

Developing IntervalLinearAlgebra.jl

intermediate
The Julia Language•2021Varies175h (Medium)

<p>The goal of this project is to implement the IntervalLinearAlgebra.jl package within the JuliaIntervals organisation and have the first release at the end of the programme. JuliaIntervals develops packages related to interval arithmetic, a mathematical framework to perform rigorous computations, treating all quantities as intervals and producing as output of computations an interval guaranteed to contain the true result. Traditional linear algebra routines, such as solving systems of polynomial equations or even just computing the cube of a matrix have been proved to be computationally challenging and designing efficient algorithms for interval matrix computations has been an active research question for a few decades. During this project, state-of-the-art algorithms for interval linear algebra will be reviewed and implemented. As linear algebra is central in practically all numerical applications, the successful completion of the project will allow to expand interval arithmetic methods also to other domains, such as reachability analysis, optimisation and differential equations solvers.</p>

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

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

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

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

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

Implementation of a hash table based on SwissTable and adding Trees.jl to JuliaCollections

advanced
The Julia Language•2020Varies350h (Large)

<p>The goal of this project would be to implement a fast open-addressed hash table inspired from Google’s <code>flat_hash_map</code>. In addition to this, I propose to work on getting an ordered version of hash tables, based on <code>OrderedDict</code>. All of these would be supplemented with proper benchmarks. Finally, I plan to work on getting several tree-based data-structures implemented and adding it to <code>DataStructures.jl</code>.</p>

cjavascriptc+++12
Student: Koustav Chowdhury
Code
Proposal

Improvements to the REPL workflow (TermLayouts.jl)

intermediate
The Julia Language•2022Varies175h (Medium)

The Julia REPL and notebooks like Jupyter Notebooks, Pluto.jl both have shortcomings, especially when considering Julia's data science work. For example, the Julia REPL requires additional packages to display images in the REPL and is inconvenient for repeated use. Images also clog the REPL, making it more inconvenient when pre-processing data. On the other hand, notebooks lack debugging tools and waste a lot of space in their layouts. A straightforward and extensible solution that uses the REPL and customizes it to our needs can bridge this feature and convenience gap. The TermLayouts.jl project aims to add extensions to the REPL and introduce a layout in which these extensions can be moved and resized to fit the user's needs. This layout can further be customized using a configuration file. This project will also seek to provide some essential extensions which most users would like to have. These extensions include a variable inspector, a fully-fledged debugger, and a plot area for displaying images. All the code will be thoroughly tested using unit tests and documented extensively for future ease of maintenance.

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

Algorithms and interface for detection of periodic orbits

advanced
The Julia Language•2024Varies350h (Large)

The main objective of my proposal is to implement better tools for detection of periodic orbits of dynamical systems. My task will be to implement unified interface for detection algorithms capable of finding orbits of both discrete-time and continuous-time systems. This will be a great addition to DynamicalSystems.jl and will allow scientists to uncover the underlying structures of complex systems. Moreover, these algorithms will provide an improved way of selecting the first seed of numerical continuation in BifurcationKit.jl.

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

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

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
Showing 673 - 696 of 3179 Projects
2728293031
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal