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

Algorithms and interface for detection of periodic orbits

advanced
The Julia Language•2024Varies

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)

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

A Generalized RAG-LLM Workflow Support Tool for JuliaHealth

advanced
The Julia Language•2026Varies350h (Large)

This project addresses the challenge of unreliable LLM outputs in complex health informatics workflows by building a domain-grounded Retrieval-Augmented Generation (RAG) system within JuliaHealth. It enables users to convert natural language queries into accurate, executable FunSQL.jl workflows by grounding responses in curated resources like OMOP and OHDSI. The project will deliver a modular baseline RAG pipeline, a reproducible evaluation framework to benchmark query quality, and clear documentation with an end-to-end demonstration for usability and future extension.

cjavascriptc+++12
Student: Param Thakkar
Code
Proposal

A Lite BERT and Statistical Language Models

intermediate
The Julia Language•2020Varies175h (Medium)

<p><a href="https://github.com/JuliaText" target="_blank">JuliaText</a> is a JuliaLang organization that provides packages to work with text. The aim of this project is to enrich TextAnalysis.jl with Framework for Statistical Language models and Practical implementation of Pretrained ALBERT.</p> <p><a href="https://arxiv.org/abs/1909.11942" target="_blank">ALBERT</a> is a deep-learning natural language processing model that uses far fewer parameters than BERT (<a href="https://arxiv.org/abs/1810.04805" target="_blank">Devlin et al., 2019</a>) without sacrificing accuracy.</p>

cjavascriptc+++12
Student: Tejas Vaidhya
Code
Proposal

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

Improving and demonstrating Julia statistical models' MCMC: CrossCat example

beginner
The Julia Language•2017Varies90h (Small)

<p>General-purpose statistical modeling tools such as OpenBugs and Stan allow using easy-to-build modular likelihood models to fit models to data through MCMC or other techniques. Crucial to the efficiency of such tools, especially as parameter dimensions increase, are tools like HMC, which allow use differentiation and/or conjugacy for continuous parameters, so that fitting is not solely a matter of getting lucky with random Metropolis-Hastings proposals. Yet some models, especially nonparametric ones, also require discrete parameters and/or hand-written jump steps; and existing tools for HMC generally don't play well with discrete parameters. My project is intended to generally improve the Julia toolchain for MCMC when there is a mix of continuous and discrete parameters. My work will be based on Mamba.jl; though when I can make something that will be useful to Klara.jl too, even better. To make that plan concrete, I'll be implementing CrossCat, a general-purpose nonparametric model for "medium-size" tabular data including missingness and various data types. (Roughly speaking, "medium-size" might mean p&lt;1e3, n&lt;1e5).</p>

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

Integrating Agents.jl with Reinforcement Learning Techniques

intermediate
The Julia Language•2025Varies175h (Medium)

The proposal aims to integrate the Julia package Agents.jl (for agent-based modeling) with ReinforcementLearning.jl or Crux.jl, enabling intelligent agents in simulations to learn optimal policies via reinforcement learning. The integration will allow for dynamic, reward-based behaviors rather than static rule-based actions. The project involves updating the chosen RL library for compatibility with the latest Julia version, building a lightweight interface (ABMEnv) to connect it with Agents.jl, and showcasing the integration through example applications like herding, civil violence, and predator-prey models. This work will expand the capabilities of Julia’s ecosystem for researchers in fields such as economics, social sciences, and robotics, while offering a standardized and accessible way to combine RL and ABM.

cjavascriptc+++12
Student: giorgio bertone
Code

Supercharging the Knowledge Base of AIHelpMe.jl

intermediate
The Julia Language•2024Varies175h (Medium)

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

cjavascriptc+++12
Student: Shreyas Agrawal
Code
Proposal

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

MuZero implementation

advanced
The Julia Language•2021Varies350h (Large)

<p>The goal of this project is to implement the <a href="https://deepmind.com/blog/article/muzero-mastering-go-chess-shogi-and-atari-without-rules" target="_blank">MuZero</a> algorithm in Julia, with the following expected benefits:</p> <ul> <li>attract people from the model-based RL community to Julia</li> <li>showcase Julia in an ambitious project that leverages its greatest strengths, and which could not be achieved using another language (with the same level of performances vs flexibility and simplicity)</li> <li>make another step towards a generic and flexible RL framework by implementing MuZero on top of <a href="https://github.com/jonathan-laurent/AlphaZero.jl" target="_blank">AlphaZero.jl</a>, reusing as much code as possible and creating new abstractions if necessary</li> </ul>

cjavascriptc+++12
Student: Michał Łukomski
Code
Proposal

De-Bruijn Graph Constructor Package for De-novo Genome Assembly

intermediate
The Julia Language•2019Varies175h (Medium)

<p>De-novo sequence assembly is the process of constructing a contiguous long sequence out of shorter sub-sequences produced by sequencing platforms, without referring to a reference genome. It is an essential task in many biological studies today, including population and medical studies. The initial stages of de-novo assembly require the construction of a de-bruijn graph (DBG) from sequencing reads, the compression of a de-bruijn graph into a unitig graph, and the compression of multiple unitigs and nodes into contigs, supported by evidence from mapping paired-end reads. A coherent ecosystem of computational tools and packages allow researchers to quickly implement and test their ideas. For bioinformatics, Julia already offers such an ecosystem in the form of the BioJulia &amp; EcoJulia projects, and additional independent packages. This project will add sequence assembly tools to the BioJulia ecosystem, specifically: 1) DBG construction from reads, 2) UG construction from a DBG and 3) Constructing contigs using unitigs. These tools will allow researchers to quickly construct and analyze the contigs obtained from a set of reads.</p>

cjavascriptc+++12
Student: Arda Akdemir
Code

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

New Features for Flux.jl

beginner
The Julia Language•2017Varies90h (Small)

<p>Flux.jl is a high-level neural network library in Julia, which has an intuitive API, easy to debug, and performant. One of the key features of Flux.jl is that it allows user to define a layer in Julia, using most Julia Array operations, while not to worry about size inference, grad calculations, etc. Unlike Knet.jl, a promising competitor of Flux.jl, which do all the tensor calculations from scratch with a lot of magics, Flux.jl simply transcompile the computation graph to mature backends like MXNet and TensorFlow. Thus, it can take the benefits of those advanced technologies and get a cutting-edge performance.</p> <p>Flux.jl is in alpha and lacks a lot of features before being actually useful. One of the problems is currently it only supports SGD optimizer without decay and momentum. It also only shows the progress during training, while saving checkpoints or doing custom evaluations once a while can help users to build a better model.</p> <p>After this program finished, Flux.jl will be able to:</p> <ul> <li>train a model with most popular optimizers like Adagrad, Adam, etc.</li> <li>hook functions at specific time point, such as after every 100 batches</li> </ul>

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

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

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

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

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

advanced
The Julia Language•2023Varies350h (Large)

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

cjavascriptc+++12
Student: Felipe Tomé
Code

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

Reachability with sparse polynomial zonotopes

advanced
The Julia Language•2022Varies350h (Large)

Reachability analysis deals with uncertainty propagation in dynamical systems. Given an initial set, modeling the uncertainty on the initial state, it aims to answer the question "What is the set containing all possible final states?" This question is relevant in several domains such as safety-critical applications and systems verification. Traditional approaches have mainly concentrated to convex sets, which can lead to overestimation of the final state when this is actually non-convex (so-called wrapping effect). Recently, Sparse Polynomial Zonotopes (SPZ) have been introduced as a set representation for both convex and non-convex sets. SPZ have been shown to have a compact representation that allows efficient manipulation. The goal of this project is to implement Sparse Polynomial Zonotopes in LazySets.jl and the corresponding reachability algorithms in ReachabilityAnalysis.jl for the JuliaReach organization. The final result will be a state-of-the-art (SOTA) toolbox for reachability analysis with sparse polynomial zonotopes, together with systematic benchmarks comparing our Julia implementation both to different implementations of the same approach and other SOTA approaches in reachability analysis.

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

Performance Enhancements and General Fixes

beginner
The Julia Language•2019Varies90h (Small)

<p>DifferentialEquations.jl is the state of the art differential equations solver that exists right now. Being written purely in Julia and having a huge number of algorithms - this package provides both complete and easy interface for users. Being said that, to maintain this state of the art performance, we need to keep updating the code and always need to have a right check in terms of performance. This project aims to do the same. The project aims to - reduce the memory consumption of the solvers, increase the speed (step optimizations), increased number of options for optional optimizations and improved benchmarking techniques.</p>

cjavascriptc+++12
Student: Kanav Gupta
Code
Proposal

High weak order stochastic differential equation solvers and their utility in neural stochastic differential equations

intermediate
The Julia Language•2020Varies175h (Medium)

<p>DifferentialEquations is a Julia package for solving differential equations in a highly performant manner within an underlying unified user interface. Recently, new promising classes of high-order methods for the weak approximation of stochastic differential equations were introduced and those solvers are yet to be implemented in the library. On top of that, Julia currently lacks adjoint sensitivity methods for stochastic differential equations. Adding these tools to the broader ecosystem of DifferentialEquations will attract researchers that seek to simulate (or even control) the dynamics as generated by stochastic differential equations. Possible fields of application range from the simulation of (bio-)chemical processes over financial modeling to quantum mechanics.</p>

cjavascriptc+++12
Student: Frank Schäfer
Code

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
Showing 1201 - 1224 of 3883 Projects
4950515253
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal