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
4718 Projects Found
Sort by

Design System Foundations (2025 Term 2)

Intermediate
•Varies

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)

Establish a lightweight, scalable design system that brings visual consistency, reusable components, and clear UX guidance across the full scope of KubeStellar. The system will support multiple user-facing surfaces, including websites, software interfaces, and CLI-based tools. This mentorship will serve as the foundational design phase, setting the stage for a future front-end development and implementation effort planned for later this year. Special emphasis will be placed on the documentation site and contributor-facing tooling to ensure immediate impact and long-term scalability. Expected Outcome: The mentorship will deliver a scalable yet lightweight design system tailored to KubeStellar's needs. It will include a component inventory, reusable UI patterns, a full CSS specification, and visual guidelines to ensure consistency and usability across the project's five active areas. While this phase focuses on foundational design work, it will directly support a future implementation phase—enabling contributors to efficiently apply the system to KubeStellar's interfaces, including UI, Docs, and CLI-based tooling. Special emphasis will be placed on ensuring the documentation site benefits immediately from this structure.

TBA
Proposal

Glee Authentication

intermediate
Postman•2023Varies175h (Medium)

This project aims to enable many authentication frameworks and add support for an authentication layer to Glee. This will give developers the ability to use Glee to create secure online applications with a variety of authentication choices. To accommodate future additions of new authentication frameworks, the authentication layer will be created to be modular and adaptable. After this project, when using Glee to build a server, the developer should be able to specify the authentication strategy they wish to support. Token-based authentication: This could be done using the jsonwebtoken npm package, provision will be made for both refresh and access tokens. Access tokens will be short-lived tokens, while refresh tokens will have longer life spans and allow for renewal of the access tokens. Basic authentication: This authentication strategy would be implemented from scratch. Certificate-based authentication: certificate-based authentication will be implemented from scratch. OAuth 2.0 authentication: OAuth 2.0 authentication will be achieved using the node-oauth2-server npm package. Session-based authentication: The viable option here will be to build the session-based authentication from scratch, as many of the options available such as passport-session, express-session, and fastify/session are all framework dependent.

javascriptnode.jsgraphql+5
Student: Alexander Godwin
Code
Proposal

Event driven architecture to improve modular design and decrease module dependencies

intermediate
The Mifos Initiative•2026Varies175h (Medium)

Mifos is moving toward a more modular architecture, but many large modules still rely on direct dependencies, which makes the codebase harder to maintain, test, and evolve. This project aims to address that problem by introducing an event-driven approach for stand-alone modules, using Spring’s application event publisher to replace one-way direct calls wherever possible. The goal is to reduce tight coupling between modules, especially in areas such as loan, savings, and group support, so that modules can become more independent and easier to package, reuse, and publish separately. The project will focus on identifying suitable direct dependencies, designing event-based replacements, implementing publishers and listeners, and validating that the new flow works cleanly without breaking existing behavior. The final deliverables will include the architectural changes needed to support event-driven communication, working implementations for selected module interactions, tests and documentation for the new design, and clear guidance for extending this pattern across the Mifos platform in the future. The broader outcome will be a cleaner and more scalable modular foundation for Mifos, making it easier for the community to build and maintain true stand-alone modules over time.

mysqljavascriptandroid+5
Student: Mansi Maurya
Code

Create a Rust crate for YOLO model

Intermediate
•Varies175h (Medium)

With WASI-NN plugins, WasmEdge is well-suited for running AI applications. However, AI applications are more than just the model. The application must pre-process data (such as images, audio and video) into TFLite / PyTorch formats, and convert the inference results back into application data in post-processing. Here are some examples: * The [mediapipe-rs](https://github.com/WasmEdge/mediapipe-rs) project provides a Rust SDK to build applications for the mediapipe AI models. * The [llama2.c](https://github.com/karpathy/llama2.c) application is [compiled to Wasm and runs in WasmEdge](https://medium.com/@michaelyuan_88928/running-llama2-c-in-wasmedge-15291795c470) to generate text using the [llama2](https://ai.meta.com/llama/) models. In this project, we would like to build a Rust SDK to support applications on the [YOLO models](https://pjreddie.com/darknet/yolo/). - Expected Outcome: - A Rust SDK that implements the pre-processing and post-processing functions required for the YOLO models. Those functions are implemented in OpenCV and Python in the official YOLO release. - Both image and video inputs should be supported. - Examples and documentation should be provided. - Recommended Skills: - OpenCV - Rust - Tensorflow / Pytorch - WebAssembly

TBA
Proposal

Mifos Mobile 6.0 - Mobile Banking App - GSoC proposal for The Mifos Initiative

intermediate
The Mifos Initiative•2023$3k–$6.6k175h (Medium)

Mifos Mobile is an android application designed for client use, which facilitates user authentication, account information viewing and editing, as well as internal transactions and repayments. In my proposal I've mentioned 4 additions to the current Mifos Mobile application. 1. Replacing the current API layer from self-service Fineract APIs to Open Banking APIs 2. Providing the user 24/7 customer chat support using RocketChat 3. Integrating external payment system, Mojaloop via the Payment Hub. 4. Covering all the screens with UI tests using Espresso. The proposed enhancements to Mifos Mobile application are expected to have a significant positive impact on the user experience. By replacing the existing API layer with Open Banking APIs, clients will be able to enjoy seamless and more secure transactions. The provision of round-the-clock customer chat support through RocketChat will ensure that users receive prompt assistance whenever they require it. Integration of Mojaloop through the Payment Hub will enhance the application's payment capabilities, and it's reach. Lastly, the coverage of all screens with UI tests using Espresso will improve the overall reliability and robustness of the application, leading to increased user satisfaction.

mysqljavascriptandroid+5
Student: Abhishek Gururani
Code

Static Memory Planner for MLIR

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

MLIR already makes allocation and deallocation structure explicit after bufferization and the ownership-based deallocation pipeline, but it still lacks an upstream static memory planner that can analyze buffer lifetimes and safely reuse memory for well-structured workloads. This is especially valuable for structured ML, HPC, and accelerator-oriented compilation flows where dynamic allocation is expensive or undesirable. I propose to build this in two incremental steps. First, I will implement an analysis pass that identifies eligible memref.alloc / memref.dealloc patterns, performs alias-aware lifetime analysis, computes planning metadata such as size and alignment, and reports reusable candidates and skip reasons. Second, I will build a conservative rewrite pass that rewrites eligible dynamic allocations into memref.subview-based slices of one or more statically allocated arena memrefs for legality-gated v1 cases. The main deliverables are: an upstream analysis pass for static memory planning, a conservative v1 rewrite pass for same-block structured cases, memory-space-aware planning support, strong lit/FileCheck coverage, documentation of supported and unsupported cases, and an incremental PR series that is realistic to review and land upstream.

cllvmc+++3
Student: KrishGupta
Code
Proposal

Hyperledger Cacti - Core Operators Modules for DLTs Mentorship Project

Intermediate
•Varies175h (Medium)

Cacti provides modules, toolkit, and protocols to enable networks built on distributed ledgers to interoperate and carry out transactions spanning their boundaries, such as asset transfers, asset swapping, and ledger data communication. For ease of building DLT-agnostic protocols in Cacti, we need to build modules corresponding to various DLTs supported by Cacti that implement these core operators and expose them using a standard API. The goals of this project are as follows: 1. Design and build DLT-specific core operator modules for Cacti by leveraging existing Cactus or Weaver packages. This involves identifying building blocks of unique features in either, and integrating legacy Cactus and Weaver packages wherever they offer a common feature. 2. Design and implement a common DLT-agnostic API, following the OpenAPI standard, using which any DLT-specific core operator module can be invoked by application-specific business logic on-demand. 3. Add suitable API support within the common Cacti client API for ease of application development 4. Do a research survey of existing blockchain/DLT literature to identify a potentially exhaustive set of core operators any DLT network must possess (or harness) to interoperate with other networks.

TBA
Proposal

Multi-stream API

advanced
NumFOCUS•2018Varies350h (Large)

<p>Gensim is an NLP library which claims to be highly effective during training and produce linear performance growth with increasing the number of threads.</p> <p>Currently, that is not true on machines with a large number of cores (&gt;10) and large data files. The reason of this is that almost all Gensim models which support multithreaded training work in the following way. There is <strong>single job producer</strong> -- worker which reads the data and pushes the chunks into the job queue. Also, there are <strong>many job consumers</strong> -- workers which pull the chunks and update the model parameters in parallel.</p> <p>The problem is that consumers' code is optimized well, so this leads to <strong>workers starvation</strong> problem. Job producer just can't fill the queue at such a high pace. This is the case even using fastest <code>read the line, split it and yield</code> corpus iterator.</p> <p>This problem could be solved by allowing users to pass <code>K</code> data streams (currently only single-stream == single job producer thread is supported), e.g. which point to <code>K</code> large files and use <code>K</code> job producers to fill the job queue.</p>

pythonjavascriptr+3
Student: Dmitry Persiyanov
Code
Proposal

Benchmarking, Python bindings and Migrating to CTest for Casbin-CPP

advanced
Casbin•2021Varies350h (Large)

<p>Casbin is an authorization library that extends its features to implement Access Control Lists, Role-Based Access Control, and Attribute-Based Access Control models in various programming languages to its clients. Casbin's Core Engine is written in GoLang. Casbin-CPP has obvious benefits of speed and efficiency compared to its implementation in other languages and thus, benchmarking is vital for the project to stand out from the rest. Python is the most versatile as well as the most used programming language and has huge community support. Casbin-CPP has the potential to support new PyCasbin to compound the benefits of both languages through language bindings and extension libraries. Currently, the project uses Microsoft Unit Testing Framework for C++ for testing and Microsoft’s Azure DevOps pipelines for CI. CTest is truly cross-platform and can be configured using GitHub Actions for consistent and better CI.</p> <p>Project Ideas are as follows:</p> <ul> <li>Modernizing the project with C++17 standard and Google’s benchmarking tool</li> <li>Implement Python bindings for Casbin-CPP using pybind11 library</li> <li>Implement testing based on CTest and set up workflows for Continuous Integration through GitHub Actions</li> </ul>

pythonjavascriptgo+7
Student: Yash Pandey
Code
Proposal

Incorporating FITS Region, CRTF I/O and improving Regions.

intermediate
OpenAstronomy•2018Varies175h (Medium)

<p>Astropy's <code>regions</code> package is being developed to handle description and manipulation of astronomical regions on sky and pixel coordinates.The current regions package has support for the most commonly used region specification, DS9, but does not yet support the <code>CRTF</code> and <code>FITS REGION</code>.</p> <p>CASA is the main package for radio interferometry data reduction and processing. CASA regions are mostly compatible with and translatable to DS9 other formats, but the only parser that presently exists, lives within CASA. <code>CRTF</code> stands for Casa Region Text Format.</p> <p>FITS , <code>Flexible Image Transport System</code> is an image format standard used in astronomy. A <code>FITS Region</code> binary table defines a spatial region of a 2-dimensional image. The region file is often used to define an area that is to be included or excluded from certain data processing operations on the image.</p> <p>The primary goal of the project is to implement I/O so the <code>regions.Region</code> objects can serialize/deserialize across these file formats , handle the meta data and spectral dimensions , improve the regions package, document and test alongside.</p>

cpythonjulia+7
Student: Sushobhana Patra
Code
Proposal

Refactor Android Client & Rewrite using Android SDK

intermediate
The Mifos Initiative•2024Varies175h (Medium)

Android Client is a mobile application that allows bank staff field officers to keep track of clients, centers, groups, loan accounts, saving accounts, and other critical information. The project aims to upgrade the Mifos Android client application by updating it to the latest dependencies and rewriting it to consume the Mifos Fineract SDK using coroutines and flows. The Android client will become the first Mifos app to utilize the Fineract SDK, thereby reducing redundant network layer code. The upgrade will involve two main migrations: transitioning from XML to Jetpack Compose and supporting a multi-module MVVM architecture organized by feature-wise modules. Additionally, the project will include supporting Kotlin Multiplatform (KMP). The upgrade will also encompass implementing unit and integration testing for features and upgrading the CI/CD pipeline for KMP and Google Play Store release pipelines. Integrating the Google Play Store API will streamline the release flow, leading to a more stable and error-free codebase, faster build times, and an improved developer experience. These changes will also facilitate smoother release management and upstream contributions, ultimately reducing the time required for upgrades.

mysqljavascriptandroid+5
Student: Aditya Gupta 99
Code

OpenLane/SKY130 Demos and tutorials

intermediate
Center for Research in Open Source Software (CROSS)•2022Varies175h (Medium)

OpenLane and SKY130 users are encountering a lot of trouble with current documentation. Even I, experienced software/VLSI developer, struggled with current documentation. For this reason, my proposal is to make a Consolidated documentation for all of SKY130/OpenLane. I worked with many students and helped a lot of people debug issues with tools. I collected feedback from them and the main struggles of students and newbies will be documented. This Wiki/Documentation proposed will cover everything that you need to start designing integrated circuits from scratch. Some amount of knowledge of Linux/Bash is assumed. I want to elevate the pressure on Skywater’s slack as the base for discussion for issues by adding a troubleshooting guide. This will allow mentors in slack to have one go-to point for all of the most common issues that they can refer to. All of the tutorials and demos are text + screenshots posted on GitHub. This is because it’s easier to update them when new versions of software come out or if the existing guide does not cover a particular topic. Videos get outdated every 3-6 months and require an effort from contributors to support. The aim is to reduce the cost of documentation support. All documentation will be proposed to developers of the according to software to be integrated into existing software’s documentation. Link to the global guide is also encouraged to allow a single consolidated entry point.

pythonc/c++verilog+2
Student: Arman @armleo Avetisyan
Code

Rule Based Integration Module for SymPy

intermediate
SymPy•2017Varies175h (Medium)

<p>Rule based integration (Rubi) consists of ~10,000 transformation rules which have been tabulated since last two centuries. Computer Algebra System(CAS) can match the integrand with the right rule to directly solve the integration without using general integration algorithms.</p> <p>Adding Rubi to SymPy can be very helpful to SymPy's integration module since it frees developers of algorithms from having to worry about the annoying and trivial problems and the special cases, and instead focus on the genuinely hard and interesting problems.</p> <p>Reference:</p> <ul> <li><a href="http://www.apmaths.uwo.ca/%7Earich/A%20Rule-based%20Knowledge%20Repository.pdf" target="_blank">A Knowledge Repository for Indefinite Integration Based on Transformation Rules by D.J. Jeffrey and A.D. Rich</a></li> <li><a href="http://www.apmaths.uwo.ca/%7Earich/" target="_blank">Albert D. Rich website</a></li> <li><a href="https://people.eecs.berkeley.edu/~fateman/papers/partition-new2.pdf" target="_blank">Partitioning of algebraic subexpressions in computer algebra systems: an alternative to matching with an application to symbolic integration by Richard Fateman</a></li> </ul>

pythonc++numpy+1
Student: Arihant Parsoya
Code
Proposal

API extensions and fixes for the p5 backend

intermediate
Processing Foundation•2018Varies175h (Medium)

<p>Last year, <a href="https://summerofcode.withgoogle.com/projects/5809403503575040" target="_blank">as a project under the Google Summer of Code</a>, I created <a href="https://github.com/p5py/p5" target="_blank">p5</a> --- a native Python implementation of the Processing API. The goal then was to combine Python's minimal syntax and pedagogical roots with Processing's high-level graphics API. While the <a href="https://medium.com/processing-foundation/p5-a-python-implementation-of-the-processing-api-5f05c62db23b" target="_blank">project was successful</a> and we <a href="https://github.com/p5py/p5/releases/tag/v0.3.0a1" target="_blank">released the first alpha as a Python package</a>, p5 is still missing some core parts of the processing API and needs better cross-platform support.</p> <p>The goal of this project is to fix existing cross-platform issues by changing the internal rendering engine to <a href="http://vispy.org/" target="_blank">VisPy</a>; fixing <a href="https://github.com/p5py/p5/issues" target="_blank">existing open issues</a>; and extending the API by adding image support, improvements to the <code>Shape()</code> class, and minor utility methods.</p>

pythonjavascriptandroid+6
Student: Abhik Pal
Code
Proposal

Accelerating RISC-V vector instructions by using a bionic network design Mentorship Project

Intermediate
•Varies175h (Medium)

Software acceleration utilizing specifically designed hardware components is a widely used technique for speeding up different kinds of kernels found in the targeted applications. An example of such kernels in High-Performance Computing (HPC) are algorithms involving the computation of sparse data structures. Sparse applications are difficult to accelerate due to their memory-bound nature, which means that the data is not accessed contiguously in memory. That implies many scatter and gather accesses to the comparatively slow memory. Consequently, dedicated hardware components capable of accelerating the scatter/gather instructions, are a key to improve the performance of sparse applications. The goal of this project is to achieve an FPGA-based acceleration of the vrgather RISC-V vector instruction (RISC-V ISA vector extension v1.0) using a bitonic network. The bitonic network is originally a sorting network that implements the merge-sort algorithm (add reference here). A number of inputs of the network can end up in any output after traversing it. When this concept is applied to a Vector Register File, the bitonic network can be used not only to sort a set of vector elements, but also to move data internally from one register to any other register. The scope of this project is limited to the execution and acceleration of the gather vector instruction, in which the variability of the vector length needs to be considered.

TBA
Proposal

grepreaper R Package Development

advanced
R project for statistical computing•2025Varies350h (Large)

The grepreaper package addresses the critical need for efficient pattern matching and selective data loading in R, particularly for large datasets. Currently, R users must load entire files before filtering, creating performance bottlenecks. My solution implements four core functions: 1. grep_count(): Counts pattern matches without loading entire files 2. grep_read(): Selectively loads only matching data 3. grep_files(): Discovers files containing specific patterns 4. grep_context(): Shows matches with surrounding context lines The package leverages system commands for pre-filtering, significantly improving performance by avoiding unnecessary data loading. It supports flexible pattern matching options, including case sensitivity control, inverted matching, and multi-pattern support across multiple files. Deliverables include: 1. Complete R package with documented functions 2. Comprehensive test suite 3. Performance benchmarks against traditional methods 4. Introductory vignette with practical examples 5. Integration with popular data manipulation workflows This project will provide R users with a powerful tool for efficient data exploration, particularly beneficial for large dataset analysis and text mining applications.

cc++r+4
Student: Atharv Raskar
Code
Proposal

Hyperledger - Automated Fault-Tolerant HTLC for Cross-Chain Atomic Asset Exchange Mentorship Project

Intermediate
•Varies175h (Medium)

The Hash Time Locked Contract (HTLC) is a well-known pattern for dis-intermediated asset swaps, i.e., as a mechanism to exchange assets between two parties in two different blockchain networks in an atomic manner without a trusted mediator (or trusted third party). HTLC support has been implemented in the Hyperledger Weaver Labs project, with mechanisms to lock, claim, and unlock assets supported in both the contract and higher application layers. At present, the protocol requires several manual steps by the application users carrying out the exchange or agents acting on their behalf. We would like to automate this process as much as possible by augmenting the relay module in Weaver to communicate events and trigger transactions in foreign networks; this requires both research and software development. Further, HTLC is known to have flaws that could violate system integrity properties, because it relies on parties to execute certain actions by a certain timeout or forever lose the opportunity to carry out those actions; this makes the basic protocol intolerant to system crashes. Research is needed to (provably) determine the best way to make the HTLC protocol fault tolerant, using the features of the blockchain networks maintaining the assets and the Weaver relays mediating the exchange. Augmenting the existing HTLC mechanism within Weaver will provide practical validation of this research.

TBA
Proposal

Finishing implementation of incomplete engines

intermediate
ScummVM•2026Varies175h (Medium)

The goal of this project is to push four nearly-finished ScummVM engines over the finish line, ensuring they are ready for official releases. Currently, these engines face issues ranging from incomplete low-level graphics and legacy code structures to unresolved gameplay bugs. How I plan to solve it: The project tackles the engines systematically. For the chamber engine, I will finalize the EGA planar graphics support and resolve memory-management issues like buffer overreads. For the avalanche engine, I will refactor the donated source code into modern C++ OOP standards, implement missing UI features, and fix gameplay logic bugs. Finally, for the DM and lilliput engines, I will conduct complete, meticulous end-to-end playthroughs to identify and fix any remaining logic, memory, or portability bugs. Deliverables: Chamber: Fully functional EGA 16-color graphics support without segmentation faults. Avalanche: A modernized, OOP-refactored codebase with a working "Shoot 'Em Up" minigame, repaired Robin Hood event trigger, missing Outro screens, and synced UI. DM & Lilliput: Stable, fully playable versions of Dungeon Master, The Adventures of Robin Hood, and Rome: Pathway to Power, fully prepared for stable public release.

openglc++assembly+5
Student: Ion Andrei Cristian
Code
Proposal

Phoenix - Experiment Independent Event Display

intermediate
CERN-HSF•2020Varies175h (Medium)

<p>Phoenix is a web-based, experiment independent event display framework in JavaScript for visualizing HEP experiment data from multiple experiments. This project focuses on the following improvements to Phoenix.</p> <h5>Improvements</h5> <ul> <li>A more feature rich, control-oriented and intuitive GUI</li> <li>Easier selection of 3D objects and event data (like Tracks, Jets etc.)</li> <li>Keyboard controls for controlling the event display through keys</li> <li>Runge-kutta propagator for using Track parameters to calculate Track positions and decreasing data format size</li> <li>Extension of the current common JSON data format to support more diverse experiments and their event data</li> <li>Support for more CERN experiments like CMS</li> <li>Loaders for loading event data from ".root" and ".ig" files</li> <li>Loading and processing event data from cloud servers</li> <li>Animation of events to simulate the propagation of particles</li> <li>Improvement of VR features</li> <li>Investigating TGeo/GEANT4 geometries and implementing converters to display them in Phoenix</li> <li>Extending unit tests and creating UI tests</li> </ul>

pythonc/c++machine learning+6
Student: Fawad
Code
Proposal

Multi-cluster Ambient testing expansion (2025 Term 2)

Intermediate
•Varies175h (Medium)

Istio is a service mesh platform used by thousands of companies to secure and manage their microservices traffic, most often in a single Kubernetes cluster. However, the ability to operate across multiple clusters is an important feature in Istio's traditional Sidecar mode, and work to support it in Istio's Ambient mode is making rapid progress. To call any feature complete, comprehensive testing is needed. Given that multicluster Istio Ambient is a new mode of operating, we will need to both adapt tests for existing features to ensure they work across multiple clusters, as well as identify multi-cluster specific scenarios we want to codify in tests. Expected Outcome: 1. Audit existing ambient integration tests for cases that do not support multi-cluster testing patterns. 2. Refactor those tests, using Istio's testing infrastructure to cover features within a multi-cluster environment. 3. Work with Istio maintainers to identify opportunities for testing new scenarios that exist only for ambient multi-cluster. 4. As documentation is written for https://istio.io, verify that the user instructions (kubectl commands, YAML snippets, etc.) actually work end-to-end. 5. Gain hands-on experience with Istio's codebase, service mesh architectures, and Kubernetes multi-clust......

TBA
Proposal

E2E test suite for Volcano agent scheduling (2026 Term 1)

Intermediate
•Varies175h (Medium)

Volcano has introduced Agent Scheduling feature that supports fast scheduling for AI agent workloads. This includes ShardingController for shard management, agent scheduler for agent workloads scheduling, and enhanced existing Volcano batch scheduler with sharding support to coordinated scheduling with agent scheduler. To ensure correctness and stability of this new scheduling mechanism, we need to build a comprehensive end-to-end (e2e) test suite. Test cases should cover key scenarios including shard creation, node assignment across shards, agent scheduler scheduling in different sharding modes, etc. - Expected Outcome: - A comprehensive e2e test suite using Ginkgo framework covering all agent scheduling scenarios. - Test cases for ShardingController: shard creation, node assignment, node addition/removal, configuration changes, and node stability across shards. - Test cases for Agent Scheduler: scheduling in no-sharding, hard-sharding, and soft-sharding modes, shard reconfiguration, and multi-worker scenarios. - Test cases for Volcano scheduler with sharding: validation of allocate, preempt, reclaim, and backfill actions under different sharding configurations. - Integration with CI/CD workflows for automated testing. - Comprehensive documentation including test design, coverage reports, and guidelines for extending tests.

TBA
Proposal

Transition to astropy time

beginner
OpenAstronomy•2018Varies90h (Small)

<p>SunPy uses python <code>datetime</code> module for handling almost all time related things. <code>datetime</code> is not the best choice for astronomy related projects due to a lot of reasons (for instance, it does not handle leap seconds). The answer is to use <code>time</code> module from <code>astropy</code>.</p> <p><code>astropy.time.Time</code> can do a lot things including:</p> <ul> <li>Handle leap seconds</li> <li>Easy conversion between format like <code>iso</code>, <code>isot</code> etc.</li> <li>Easy conversion between scales like <code>utc</code>, <code>tai</code> etc.</li> <li>Can be initialized from and converted to a lot of popular time formats and even supports python <code>datetime</code>.</li> <li>Ability to create custom classes to support extra formats of time.</li> </ul> <p>This makes <code>astropy.time</code> the best candidate to replace python <code>datetime</code> in SunPy.</p> <p>This project will transition the whole of SunPy to use <code>astropy.time</code> instead of python <code>datetime</code>.</p>

cpythonjulia+7
Student: Vishnunarayan K I
Code
Proposal

Fix outstanding issues in Brian2CUDA

advanced
INCF•2026Varies350h (Large)

Problem: Brian2CUDA offers significant GPU acceleration for neural simulations, but its current "beta" state contains friction points that hinder widespread adoption. Key issues include unreliable Windows support due to POSIX-specific build assumptions, slow incremental compilation that often exceeds simulation time, silent GPU failures that are difficult to debug, and startup crashes related to preference file validation. Solution: This project aims to make Brian2CUDA "production-ready" by modernizing its backend infrastructure without adding heavy external dependencies. The plan involves: Stabilizing the Windows workflow by implementing a robust nmake/MSVC build path and platform-independent path handling. Optimizing compilation speed through deterministic source grouping and granular dependency tracking in generated Makefiles. Implementing a synchronized C++/Python logging system with structured CUDA error-checking to eliminate silent failures. Resolving preference validation conflicts to ensure reliable configuration loading. Deliverables: - A validated cross-platform build system supporting Windows (nmake) and Linux/macOS (Makefile). Optimized code-generation templates for faster incremental builds. A unified diagnostic logging framework. A suite of regression tests and "Getting Started" documentation for Windows users.

pythonjavac+++7
Student: Weiyuan Du
Code
Proposal

OpenModelica Integration

advanced
Scilab•2017Varies350h (Large)

<p><strong>Modelica</strong> is an object-oriented and declarative language specification for description/modeling of dynamic systems (mechanical, electrical, thermal, mixed, etc.). <strong>Scilab</strong> uses it inside <strong>Xcos</strong> to describe more complex blocks/components, taking advantage of existing compiler/translator implementations to generate correspondent <strong>C</strong> code for actual simulation.</p> <p>For now, <strong>Modelica</strong> in <strong>Scilab</strong> is managed by an out-of tree compiler developed by <strong>LMS</strong> released under the <strong>GPL</strong> license, which is not actively maintained and support only a subset of the current language specification. The idea of this project is to allow the usage of <strong>OpenModelica</strong>’s <strong>OMCompiler</strong> (<strong>omc</strong>) as an alternative. Being a more up-to-date solution, <strong>omc</strong> integration would provide <strong>Scilab</strong>/<strong>Xcos</strong> the ability to use more advanced features, and avoid bugs, issues and maintenance burden of the current <strong>modelicac</strong> compiler.</p> <p>Adapting <strong>Xcos</strong> blocks to support the <strong>FMI2 API</strong> standard would allow not only omc-generated code to be called but also any other FMI2-compliant applications to be easily integrate in the future.</p>

cpythonjava+3
Student: Leonardo José Consoni
Code
Proposal
Showing 2665 - 2688 of 4718 Projects
110111112113114
Proposal
Proposal
Proposal
Proposal