Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
3883 Projects Found
Sort by

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

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

Ab-Initio Quantum Chemistry with Rimu.jl

intermediate
The Julia Language•2025Varies175h (Medium)

This project proposes adding new features to Rimu.jl --- a Julia package that implements a random integrator for many-body quantum systems --- allowing it to read FCIDUMP files or directly use data from the ElemCo.jl package and construct a molecular Hamiltonian. This will provide users with the ability to obtain highly accurate data from quantum Monte Carlo simulations and exact diagonalisation for extensible models involving the electronic structure of molecules starting from readily available quantum chemistry data.

cjavascriptc+++12
Student: lch
Code
Proposal

MLJTime - Adding Time Series Support For MLJ

intermediate
The Julia Language•2020Varies175h (Medium)

<p>The main goal of the project is to port capability from​ sktime​ (Machine learning for time series) to MLJ universe &amp; develop data container to handle time series data in modular, composable way.</p>

cjavascriptc+++12
Student: Aadesh Deshmukh
Code
Proposal

Symbolic computation with Julia (Symbolics.jl): Symbolic Root finding

intermediate
The Julia Language•2024Varies175h (Medium)

Currently, Symbolics.jl has a Groebner basis implementation which is able to convert a myriad of symbolic expressions into multi-variate polynomials. This can be incredibly useful for solving functions for their roots, but to do so, a root finder for these generated polynomials must be implemented. Moreover, multiple users of Symbolics.jl have requested a symbolic nonlinear solver. As such, the project aims to complete the following: 1- Solve single variable polynomials (even high degree ones n ≥ 4) and multi-variable polynomials (over 2 dimensions or more) 2- Solve transcendental / other types of non-linear equations (highly requested: issues #961, #468, and #866) 3- Ensure that the implementation is well tested and well documented to make it more user-friendly and help out future contributors of the project.

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

Random Number Generators for Julia language

advanced
The Julia Language•2016Varies350h (Large)

<p>The random number generator(RNG) of Julia needs updating to a more reliable one. I'm going to implement a package (may be named RNG.jl) providing several RNGs, and a binding to Intel MKL(VSL.jl) for the RNG work. After comparing the performance of them the best one is supposed to replace the current RNG in Julia Base.</p>

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

Survey.jl

advanced
The Julia Language•2023Varies350h (Large)

Survey.jl is a Julia package for survey analysis inspired by the R package 'survey'. It aims to address the unique challenges associated with the analysis of large survey datasets, such as weighting, clustering, and stratification. I will be completing the implementation of generalized linear models, adding support for more complex survey types, creating helper functions as needed, and helping to refactor parts of the codebase.

cjavascriptc+++12
Student: Nadia Enhaili
Code
Proposal

Enriching Model Zoo with Deep Learning Models

intermediate
The Julia Language•2019Varies175h (Medium)

<p>The aim of this project is to enrich Flux Model Zoo with unsupervised deep learning models, in particular variants of Generative Adversarial Networks. I propose to add the following models : 1) Spatial Transformer Networks 2) StarGAN for facial expression synthesis 3) VAE-GAN 4) Energy Based GAN 5) Gated Recurrent Convolutional Neural Network</p>

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

Automatic differentiation in density-functional theory

intermediate
The Julia Language•2021Varies175h (Medium)

<p>Density functional theory (DFT) is a key driving force in modern quantum chemistry, with applications ranging from materials science to drug discovery. From a numerics perspective it amounts to solving a coupled system of non-linear partial differential equations. This is the setting of the density functional toolkit DFTK.jl, a Julia package for solving DFT problems.</p> <p>Can we make a full DFT solver differentiable via automatic differentiation (AD)? There are at least three reasons why this is an interesting problem:</p> <ol> <li>It will enable faster model design iterations for chemists, providing useful model derivatives automatically.</li> <li>It will enable research into novel combinations of machine learning and DFT.</li> <li>It is technically challenging from an AD perspective. We expect to raise rough edges and collaborate on smoothing them out. We believe it has the potential to become a showcase of the Julia ecosystem and AD compositionality on a large scale.</li> </ol>

cjavascriptc+++12
Student: Niklas Schmitz
Code
Proposal

Project 4: Adding dataset-wide functions and integrations of augmentations

advanced
The Julia Language•2024Varies350h (Large)

MedPipe3D is a Julia package that enables working on GPU-accelerated medical image segmentation. MedPipe3D aims to merge MedEye3D, MedEval3D, and MedImage into one coherent pipeline. The project includes developing: Augmentations for medical data, Invertible augmentations and support test time augmentations, Patch-based data loading with probabilistic oversampling, Calculate Median and Mean Spacing with resampling, Basic Post-processing operations, Structured configuration of all hyperparameters, Visualization of algorithm outputs, K-fold cross-validation functionality. Streamlining processes around libraries and increasing both model performance and user experience.

cjavascriptc+++12
Student: JanZubik
Code
Proposal

Model Serialization and Pathfinding for Agents.jl

advanced
The Julia Language•2021Varies350h (Large)

<p>Agent-based models (ABMs) are simulations in which autonomous entities (known as agents) react to their environment (which includes other agents) based on a predefined set of rules. The objective is to analyze the effect of agent behavior on the model as a whole. Agents.jl is a pure Julia library that assists with the creation of performant ABMs. It provides various tools and utilities to simulate complex agent-model behavior with little effort. My proposal is to add the following two features that are currently not present in Agents.jl:</p> <ol> <li>Serialization and deserialization of model state</li> <li>Extending pathfinding functionality<ul> <li>Pathfinding in continuous space</li> <li>Low-level control over the pathfinding API</li> </ul> </li> </ol>

cjavascriptc+++12
Student: Aayush Sabharwal
Code

FastAI.jl Development

advanced
The Julia Language•2021Varies350h (Large)

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

cjavascriptc+++12
Student: Manikya Bardhan
Code
Proposal

Named Entity Recognition and Part-of-Speech APIs and models

intermediate
The Julia Language•2019Varies175h (Medium)

<p><a href="https://github.com/JuliaText" target="_blank">JuliaText</a> is the JuliaLang organization that provides with packages to work with text. It currently lacks support for basic problems like Named Entity Recognition, Part-of-Speech Tagging, Dependency Parsing etc. which help serves as the basis for various language processing problems and analysing text.</p> <p>I propose to implement practical models for Named Entity Recognition and Part-of-Speech Tagging in Julia and extensively test and validate them. Robust and well-tested APIs for these two tasks will be written.</p>

cjavascriptc+++12
Student: Ayushk4
Code
Proposal

GPU Acceleration for PDE Discretization in Trixi.jl using CUDA

beginner
The Julia Language•2023Varies90h (Small)

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

cjavascriptc+++12
Student: Huiyu Xie
Code
Proposal

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

Differentiable Tensor Networks

advanced
The Julia Language•2019Varies350h (Large)

<p>This project aims to improve the tooling for tensor network algorithms in julia and demonstrate advantages of julia - composability, performance, ecosystem among others - by implementing cutting edge differentiable tensor network algorithms that integrate tools from machine learning, quantum mechanics and mathematical optimisation. The end-result will be a new julia implementation of the einsum-interface and a cutting edge package for differentiable tensor network algorithms, reproducing results of a recent paper that represents the new state-of-the-art in infinite two-dimensional tensor networks.</p>

cjavascriptc+++12
Student: Andreas Peter
Code
Proposal

Implementing Advanced Variational Gaussian Process Models

beginner
The Julia Language•2021Varies90h (Small)

<p>Gaussian processes (GPs) are flexible probabilistic models with a wide a variety of applications. However, in their simplest form they scale notoriously poorly with large datasets. There has been much work in recent years to develop approximate methods which enable GPs to be used with much larger datasets.</p> <p>This project will focus on implementing such approximate methods for Gaussian processes within the JuliaGaussianProcesses ecosystem with the goal of achieving performance which is competitive with similar established Python packages (specifically GPFlow and GPyTorch).</p>

cjavascriptc+++12
Student: Ross Viljoen
Code
Proposal

Electron App for Pluto

intermediate
The Julia Language•2022Varies175h (Medium)

Problem: Installing Julia, opening a terminal, running Julia REPL, then opening the package manager, adding Pluto package, running Pluto, and then going to the browser to run it. How many steps was it? 7. Seems quite uninviting. Now think of a person who has never touched any terminal in his life. Seems like an even more daunting task. A person who is only interested in running a Pluto Notebook and running Julia on it may or may not know how to do any of these steps, and since these can be automated, why keep this task to the end user? My Plan to solve: This is where this app comes in, bundles all these steps, runs this in the background, and then only shows the user their notebook running inside the app itself, no browser required. Deliverable: An Electron app that can perform the following tasks: 1. Install Julia and pluto on the first run. 2. Show the pluto view inside the app. 3. Allow the view to interact with the server. 4. Support the native file system features of Pluto. 5. Support running more than one instance of Pluto views. 6. Support light and dark modes. 7. Be responsive (allow different screen sizes). 8. Show the Julia Package Page inside the app itself to refer to some documentation when and if required. 9. It should also have proper comments and documentation for future reference.

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

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

Particle Swarm Optimization for Hyperparameter Tuning in MLJ

intermediate
The Julia Language•2021Varies175h (Medium)

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

cjavascriptc+++12
Student: Huu Long Nguyen
Code

Deep Learning for 3D Computer Vision

beginner
The Julia Language•2020Varies90h (Small)

<p>Neural Networks (NN) is one of the most fundamental building blocks of modern Computer vision and it has found its relevance in multiple domains like image, text, audio, and many more. Various operations, convolution operation in analysing images to recurrent neural networks used to process text uses the principle of NN. Also, researchers have come up with novel deep learning architecture to analyse and find high-order patterns in domains like 3D structure.</p> <p>However, it is not easy to implement domains like 3D computer vision with essential utilities of NN library (which is primarily focused on classic computer vision). Implementation can generally become complicated and confusing. Also, it's no longer deemed necessary among deep learning enthusiasts to know the traditional computer vision algorithm from the implementation point of view, but they are beneficial from the understanding point of view. Therefore a framework which can unifies and ease the task of 3D vision will be useful to the community.</p>

cjavascriptc+++12
Student: Nirmal Praveen Suthar
Code
Proposal
Showing 1249 - 1272 of 3883 Projects
5152535455
Proposal
Proposal
Proposal
Proposal
Proposal