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

imputeTestbenchG: Imputation Testbench for Genomics data

advanced
R project for statistical computing•2022Varies

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)

Data Cleaning is one of the important and time-consuming steps in the Data Science and Data Analytics field. There are numerous methods, models, and algorithms for data cleaning processes that might be categorized under imputation, outlier detections, formatting, and visualizations among others. The process of evaluating these methods for a given dataset is challenging considering the volume of the dataset and the time/space complexities of the methods. Automation of the performance evaluation process can lead to a significant reduction in human efforts and time consumption with an unbiased comparison environment. The imputeTestbench package provides a benchmarking tool for automated performance evaluation and comparison of various imputation methods for time-series datasets. In its present form, the package is capable of handling time-series and temporal datasets. Imputation plays a crucial role in the fields of genetics and genomics. The aforementioned package can be very helpful if it can be modified to handle genetic or genomics datasets. It has huge potential in handling genetic/ genomics datasets and introducing parallel-processing and high-performance computing concepts. Considering these as a motivation, the goal of the project is to develop a new R package, modifying the imputeTestbench package for Genomics applications with better computational capabilities and will be named 'imputeTestbenchG'.

cc++r+4
Student: Mayur Shende
Code
Proposal

DMA-BUF based high performance backend for screen capture in the libwayshot library

advanced
Waycrate•2024Varies350h (Large)

I propose to work on the creation of a DMA-BUF backend for waycrate’s libwayshot screen capture library. Presently libwayshot’s method of screen-capture requires copying from graphics memory to system memory via CPU using the shared memory methods of the wlr-screencopy protocol. This method has too much overhead for uses like high resolution streaming: any further transforms and processing of the image will either be performed on CPU (inefficient) or require another copy back onto graphics memory. There is a better way to do this. The DMA-BUF (short for Direct Memory Access Buffer) is a Linux kernel framework that allows for efficiently sharing buffers of memory between multiple graphics devices or subsystems. Using the DMA-BUF export mechanisms in wlroots we can completely avoid downloads and uploads between graphics memory and the CPU, thus allowing for increased efficiency and performance. This will be especially noticeable on higher resolution screen-captures where individual frame buffers become too large to be efficiently dealt with on a CPU compared to how they can be handled on the GPU. The Deliverables for this project are: Complete implementation of a high-performance DMA-BUF based screen capture backend in libwayshot, Documentation for using it.

cc++rust+2
Student: Sooraj S
Code

Integrate app as microservice and implement the interaction and sharing features

intermediate
FOSSASIA•2018Varies175h (Medium)

<p>The aim is to enable multiple web-apps generations by implementing <strong> queue data structure</strong> for the series of requests triggered by users from the open-event platform. This would prevent loss of requests from the user and enable the creation of event for every request and provide a web-service for direct generation of event sites from the orga-server(eventyay). In the present implementation, we have transformed websites generated through open-event-webapp to be <strong>Progressive Web App(PWA)</strong>, due to which service workers are already enabled. Therefore we can now move to further enhancement like push-notifications of bookmarked events by any user, also we need to improve the user interface for the <strong>dark theme</strong> enabled recently to project. The present testing suite requires some more tests for the functionalities like direct linking of tracks and rooms so the aim is to write <strong>mocha unit tests</strong> with selenium webdriver for the recently added features and the proposed ones. The travis build for the selenium tests run for around 20 minutes, which is quite large so the aim is to <strong>parallelize the build</strong> so that multiple builds can be performed at the same time and runtime can be decreased significantly.</p>

pythonjavascriptandroid+7
Student: Ayush Gupta
Code

AI Assisted ArduPilot Log Diagnostics and Configurator Recommendation System

intermediate
ArduPilot•2026Varies175h (Medium)

ArduPilot flight logs are currently analyzed manually, making it difficult to understand why crashes or unexpected behavior occur. Users have to inspect multiple signals across time, which requires experience and is not reliable for most people. A Python tool that runs locally and takes a .BIN log as input. The data is aligned across time and processed to extract signals such as attitude error, battery behavior, GPS error and other signals. Physics-based checks detect sustained issues based on flight behavior, while a Hidden Markov Model observes patterns over time to filter out short disturbances. Results are treated as reliable when both agree over a consistent duration. An LLM based agent coordinates the workflow by running the analysis steps and combining their outputs into a clear explanation, while all calculations follow rule-based logic. The analyser adapts to different firmware versions by reading parameters and detecting configuration related issues by comparing them with expected ranges from the ArduPilot codebase. It outputs what happened, when it happened, and why, along with linked telemetry evidence and possible fixes. Deliverables include a complete Copter focused diagnostic pipeline, ML integration, dynamic parameter lookup, structured output generation, and a packaged command line tool with documentation.

pythonrosc+++8
Student: Omkar Sarkar
Code

Image captioning and Object detection add-ons for NVDA

intermediate
NV Access•2020Varies175h (Medium)

<p>The internet today is rich in image-content, from entire websites like Instagram and Pinterest dedicated to curating and displaying images, to Facebook and Reddit that have large amounts of content in image form. Non-visual users find it challenging to navigate and use these websites for their intended purpose. The information in images, whether on the internet or stored locally, is also inaccessible to non-visual users. NVDA or NonVisual Desktop Access is a free, open-source, portable screen reader for Microsoft Windows. It already includes an OCR that can recognize text within images, however, it lacks any functionality to describe image content and allow users to interact with the various objects within images. This project aims to overcome these issues through two modules:</p> <ol> <li>A machine learning module to generate descriptive captions for images on the user’s screen or those manually inputted by the user.</li> <li>An object detection model that draws bounding boxes around recognized objects and outputs the object label when the user’s pointer enters a bounding box. The outputs of both these modules could be presented to the user using NVDA’s existing mechanisms such as voice or braille.</li> </ol>

pythonc++ui automation+2
Student: Shubham Dilip Jain
Code
Proposal

Semi-automated DroidBot: Semi-automated Android UI testing

beginner
The Honeynet Project•2018Varies90h (Small)

<p>The solution will consist of an Android app, that will read the input provided by the user, and generate an interaction model, which can be read by DroidBot, and used for automating the appropriate view.</p> <p>Firstly, for every new page, a layout will be generated. The dumpWindowHierarchy method can be used to dump the layout to a file, and this file can be read to understand the events associated with it. This will be useful later, when the input events need to be reconciled.</p> <p>Touch input events will be recorded using the getevent tool. Simple touches and gestures will be differentiated. Only events that are contained within the layout area will be processed by the system.</p> <p>Since getevent isn't reliable for keypress input, it cannot be used. Instead, an IME that logs text input will be implemented. This reduces logical complexity by not having to parse getevent logs for keyboard input, when keyboard layouts can vary wildly.</p> <p>The input events will be reconciled with the UI, by performing the input actions on the innermost element that the X and Y values of the input were contained within.</p> <p>Interactions can be sent to droidbot either as a script, or by directly deserializing the UTG class.</p>

pythonandroidmachine learning+16
Student: Anant Joshi
Code

Migration of docs.meshery.io from Jekyll to Hugo (2026 Term 1)

Intermediate
•Varies175h (Medium)

The Meshery documentation docs.meshery.io (https://docs.meshery.io/) is a critical resource for users and contributors. Currently built using Jekyll, the site faces limitations in build speed, scalability, and long-term maintainability. Hugo, a modern static site generator, offers significantly faster build times, better content organization, and an improved developer experience. This internship focuses on migrating the entire docs.meshery.io (https://docs.meshery.io/) site from Jekyll to the Hugo framework, using docs.layer5.io (already implemented in Hugo) as a reference architecture. The migration will involve porting all documentation content, assets, layouts, and configuration while preserving URLs, SEO, contributor workflows, and existing auto-generated documentation files. Expected Outcome: i. Revamp of documentation set information architecture. Alignment with Diataxis framework. ii. Updated contributor docs. iii. All self-documenting aspects accounted for: a. Compatibility tests of Meshery Adapters. b. End-to-end tests of Meshery UI. c. Integration of Meshery Catalog and all designs. d. Publication of community discussion forum activity per category. e. Integration of Meshery Models (Integrations)

TBA
Proposal

BiniBFT Implementation - The Optimized BFT on Fabric

Intermediate
•Varies175h (Medium)

Blockchain technology has a wide range of day-to-day applications ranging from electronic voting to supply chain management to financial transactions to healthcare management, energy management etc in a distributed and a decentralized environment. The enterprise blockchain provides transparency and immutability in a permissioned setting. The consensus protocols play a crucial role in establishing trustworthiness within these systems, facilitating secure and reliable operations across various sectors. The seamless integration of Byzantine Fault Tolerance (BFT) further fortifies the trustworthiness of enterprise blockchain. To achieve high security and scalability this project implements the BiniBFT consensus for Hyperledger Fabric, which was successfully innovated and designed after careful research through the CLP 2023 project, BiniBFT - An Optimized BFT on Fabric. This mentorship project highlights the pivotal role of blockchain and BiniBFT in revolutionizing the reliability and security of day-to-day operations across industries, offering a glimpse into the transformative potential of decentralized technologies in shaping the future of sustainable digital ecosystems. The project will start with the implementation of BiniBFT consensus. Both the versions of BiniBFT namely BiniBFT with Random Polling, and The Time-Weighted BiniBFT Consensus protocol will be implemented. The documentation phase will happen along with the implementation to have better clarity for users.

TBA
Proposal

nicheR shiny: Interactive GUI for ellipsoid-based virtual niches

intermediate
R project for statistical computing•2026Varies175h (Medium)

Virtual niche simulations are a powerful tool for testing ecological theory, and nicheR provides an integrated, R-native framework for ellipsoid-based virtual niche construction, prediction, and data generation. This project will deliver a Shiny graphical user interface for nicheR, making these tools accessible to researchers regardless of their programming background. The app will guide users through a complete virtual niche workflow across six tabs: data input, niche design, prediction, bias preparation, data sampling, and reproducibility. Throughout, contextual messages will explain the ecological meaning of key parameter choices, ensuring users understand the theory behind what they are building rather than just clicking through steps. A key feature is that every interactive session generates a fully reproducible R script, so users can transition seamlessly from the GUI to scripted workflows. Deliverables include a fully functional Shiny app packaged within nicheR with a run_app() launcher, test cases for each module, and two vignettes. By lowering the technical barriers to ellipsoid-based niche modeling, this project expands access to rigorous, theory-driven tools for ecologists, conservation practitioners, and students across the R community.

cc++r+4
Student: Mariana Castaneda Guzman
Code

Intelligent Execution Engine, Adaptive Scheduling & Advanced Tooling Integration

advanced
OWASP Foundation•2026Varies350h (Large)

OWTF's current architecture has four systemic bottlenecks: workers that sit idle between single-task fetches, a FIFO scheduler with no priority or adaptive feedback, fragile plugin execution with no retry or timeout control, and an outdated tool ecosystem missing industry-standard scanners. This project replaces the flat task queue with a priority-based adaptive scheduler using a min-heap, where tasks are scored by plugin weight, risk factor, target priority, and a real-time feedback boost that re-prioritizes the queue when vulnerabilities are discovered. The worker model is upgraded with batch fetching, async pre-fetching, dynamic scaling, and target-affinity batching to eliminate idle gaps. A resilient execution harness adds configurable timeouts, retry with exponential backoff, subprocess isolation, and structured logging to every plugin run. Five modern tools are integrated using a self-contained plugin pattern: Nuclei, httpx, Subfinder, Katana, and ffuf. Deliverables: working adaptive scheduler, optimized worker pool, resilient plugin harness, five new tool plugins, HTML reporting with CVSS severity grouping, and comprehensive benchmarks showing measurable improvements in scan time and coverage.

pythonjavascriptjava+10
Student: Abhay Bansal
Code

MDAnalysis x ProLIF Project 5: H-Bond interactions from implicit hydrogens

beginner
MDAnalysis•2025Varies90h (Small)

ProLIF, a tool for identifying protein-molecule interactions in molecular dynamics trajectories, lacks a straightforward method for evaluating hydrogen bonds when only heavy atoms are present. Many users usually compare experimental and computational structures without explicit hydrogens, but the existing protonation tools are cumbersome and error-prone for beginner-level programming users. This proposal introduces an "implicit hydrogen bond (H-bond) interaction method" directly using heavy atom positions to detect H-bonds. The goal is to strike a balance between efficiency and accuracy and increase ProLIF's usability. The method will leverage distance-based calculations with geometrical constraints, similar to Mol* and Chimera, and incorporate a confidence score based on AutoDock Vina's hydrogen bond term. Standardizing residue names from various force fields (CHARMM, AMBER, GROMOS, OPLS-AA) and assigning their associated protonation/hybridization states will be crucial for the new "Protein helper function” before the H-bond detection. Lastly, I plan to use the PINDER and PLINDER datasets (protein-protein and protein-ligand interactions, respectively) to validate the implicit H-bond interaction method by comparing the results from the standard H-bond method.

pythoncythonc/c+++1
Student: Yu-Yuan (Stuart) Yang
Code

Finish converting submodule to builtin

advanced
Git•2021Varies350h (Large)

<p>Git has historically had many components implemented in the form of shell scripts. This was less than ideal for several reasons:</p> <ul> <li>Portability: Non-POSIX systems like Windows don’t play nice with shell script commands like grep, cd and printf, to name a few, and these commands have to be reimplemented for the system. There are also POSIX to Windows path conversion issues.</li> <li>No direct access to plumbing: Shell commands do not have direct access to the low level Git API, and a separate shell is spawned to just to carry out their operations.</li> <li>Performance: Shell scripts tend to create a lot of child processes which slows down the functioning of these commands, especially with large repositories.</li> </ul> <p>The goal of this project is to complete the conversion of the remaining parts of <code>git submodule</code> to C, namely, the <code>add</code> and <code>update</code> commands. If possible, I intend to even get rid of the shell script called <code>git-submodule.sh</code> entirely, which currently calls <code>submodule--helper</code> to perform most of the business logic, and instead make <code>submodule</code> a proper builtin in pure C.</p>

cshell scriptgit+2
Student: Atharva Raykar
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

Improving the SweetCam IP camera honeypot

advanced
The Honeynet Project•2025Varies350h (Large)

Problem: IP cameras are frequent targets for cyberattacks due to their widespread use and often weak security. Current honeypots like SweetCam lack comprehensive protocol support and realistic emulation, limiting their effectiveness in detecting and analyzing threats. Solution: This project aims to transform SweetCam into a versatile, multi-protocol honeypot by: 1. Expanding protocol support for RTSP and ONVIF, enabling deeper interaction with attackers. 2. Introducing template-based device emulation using YAML to simulate real-world cameras (e.g., Dahua, Hikvision). 3. Improving usability with Docker enhancements, automated configuration, and a realistic HTTP interface featuring error simulation and multi-language support. Deliverables: 1. A production-ready SweetCam with RTSP/ONVIF support and 5+ device templates. 2. Optimized Docker deployment (multi-stage builds, Compose profiles). 3. Enhanced HTTP interface (login flows, error simulation, i18n). 4. Comprehensive documentation, including setup guides and protocol specifications. Impact: This upgrade will equip researchers and defenders with a powerful tool to study attacker behavior, improve IoT security, and contribute to the broader honeypot ecosystem.

pythonandroidmachine learning+16
Student: c1nk
Code
Proposal

Improve CrashDragon API Consistency, Auth Reliability, and Frontend Completion (Go + Vue.js)

intermediate
VideoLAN•2026Varies175h (Medium)

CrashDragon plays a critical role in transforming VLC crash reports into actionable fixes, but current gaps in API consistency, auth-sensitive behavior, and frontend completeness introduce friction in triage and integration workflows. This project is a continuation of prior work and focuses on improving reliability without breaking existing functionality. The approach includes: Reviewing current API and frontend behavior to identify inconsistencies between public routes and /api/v1. Improving the Go backend by standardizing API response contracts, tightening validation, and hardening auth-sensitive mutation paths while preserving backward compatibility. Completing missing frontend surfaces and aligning Vue service-layer logic with typed API contracts to eliminate fragile response handling. The project will be delivered through incremental, review-driven changes with strong regression testing and CI validation to ensure stability. Deliverables: Consistent and well-defined /api/v1 API behavior with improved validation and error handling. Hardened authentication and mutation route reliability. Completed frontend views (stats, symfiles) with contract-aligned data handling. Expanded backend regression tests and improved documentation. Final implementation report and follow-up issue roadmap.

copenglc+++10
Student: Priyanshu Thapliyal
Code

Hyperledger - Fabric-Ethereum token bridging Mentorship Project

Intermediate
•Varies175h (Medium)

One of the key use cases of blockchain integration is asset bridging: in essence, "locking" an asset (typically, a native coin or token) in a smart contract on its authoritative ledger and making available corresponding, newly minted (wrapped/shadow/...) assets on another. By now, bridging is supported by quite mature solutions in the cryptoworld; however, the same is not true for "consortial" distributed ledger technologies. At the same time, such functionality can be expected to become an important requirement in the not too distant future - Analysing the implementation approaches of standard "token models" (ERC20, ERC-721, ... - as far as this has been already done) in native Fabric chaincode and creating conceptual mappings between standard Ethereum token types and Fabric-native assets (including, but not limited to, the different authentication and authorization approaches). - Creating a brief review of the bridging approaches and mature technologies widely used in the cryptoworld. - Performing a requirement analysis for bridging assets from Fabric to Ethereum-based networks (and back), taking into account that the parties performing the bridging have to be explicitly given permission to do so by an authority and may be subject to regulatory requirements. - Based on the available open-source components, designing and prototyping a Fabric-Ethereum bridge fulfilling the requirements As the proposed project bridges multiple fields, creating a centralized solution.

TBA
Proposal

OpenWhisk performance improvement - work stealing, priority-based scheduling on load balancer and direct connection for streaming capabilities.

advanced
Apache Software Foundation•2018Varies350h (Large)

<p>The emergence of serverless computing moves cloud/edge to the next generation of resource sharing: function as a service. The innovation makes developer released from provisioning, updating, and managing servers under flexible scalability and fault tolerance. Also, the most influential outcome is no computing cost when idle, which is also known as pay as you go model.</p> <p>However, the performance is under critical to be improved, i.e., more servers required in existed serverless platform, high and not predictable round-trip latency, especially under high concurrency and keeping dependable.</p> <p>Here come some places to improvement, including shortened path, performance improvement on invoker, serialization elimination, and scheduling. In the first step, the picked-up topic: <strong><em>work-stealing and priority-based scheduling and direct connection for streaming capabilities</em></strong> will be a great and valuable choice.</p> <p>Goal on this project</p> <ol> <li>Work-stealing scheduling on load balancer.</li> <li>Direct connection for stream support.</li> <li>Priority-based work-stealing scheduling.</li> <li>Comprehensive tests to avoid bugs on concurrency and distributed failure.</li> <li>Performance tests and optimization.</li> </ol>

pythonjavascriptjava+7
Student: Tzu-Chiao Yeh
Code

Enhancing the Magic ePaper App for a Functional and Seamless User Experience

beginner
FOSSASIA•2025Varies90h (Small)

This project focused in converting the concept of Magic ePaper App into a feature-packed, cross-platform app for personalized ePaper display powered by NFC. Central to it is a robust image editor, developed on the basis of the pro_image_editor package, offering users simple yet effective tools for painting, text styling, and embedding emojis, as well as tuned image adjustment controls. Key achievements encompass the creation of a sophisticated image processing pipeline, complete with advanced dithering filters such as Atkinson and Floyd-Steinberg. Additionally, a dynamic color quantization system was designed, adeptly adapting to the specific palette of the chosen hardware. Importantly, support for a new range of Waveshare displays was seamlessly integrated by harnessing their native SDK; this was accomplished through a Flutter Method Channel coded in Kotlin. In addition to the fundamental editor and image pipeline, new functionality was added directly into the edit experience, such as a flexible Barcode Generator, Customizable Design Templates, and an XBM Export capability. I also established the groundwork for internationalization (i18n) and added out the CI pipelines with GitHub Actions for auto-building and running Integration tests. The project is now an agile and accessible tool that enables users to quickly create dynamic, green content for ePaper badges.

pythonjavascriptandroid+7
Student: Vishveshwara Uthayakumaran
Code

WebFL - WebGPU for Federated Learning

advanced
C2SI•2024Varies350h (Large)

Federated Learning (FL) is a machine learning (ML) approach that allows models to be trained collaboratively and distributedly without sharing individual data points. WebGPU, a modern web standard and API, provides low-level, high-performance access to a device's GPU through web browsers. It aims to enable developers to create complex graphical applications and experiences on the web by utilizing modern GPU hardware for efficient graphics rendering. Due to their extensive usage and customized optimizations, current Federated Learning (FL) systems frequently concentrate on certain device types, such as smartphones or Internet of Things (IoT) devices. Nevertheless, FL's adaptability to other device kinds may be limited by this device-centric optimization, necessitating substantial coding and redesign work to modify FL systems for diverse device types. Because developers wind up building different and fragmented codebases for each device, this method violates software engineering principles of code reusability, making maintenance more difficult and impeding the effective deployment of FL. In this proposal, a novel WebGPU based federated learning network for heterogeneous device network is proposed. The proposal aims to deliver a working federated learning system supported by web browsers along with additional features.

pythonjavago+2
Student: emsdv
Code
Proposal

IntelliJ plugin for Real-Time Updates with analyzer-lsp (2024 Term 3)

Intermediate
•Varies175h (Medium)

Konveyor provides a unified experience of tools to help organizations modernize their applications at scale, transitioning them to Kubernetes and cloud-native technologies. Recently the Konveyor community began the development of a Generative AI approach for application modernization called Konveyor-AI. Konveyor AI accelerates application migration by discovering migration incidents in the source code and providing LLM-generated fixes in a diff view presentation. When proposed changes are accepted, it provides real-time updates on the number of incidents. The presentation side for this work is currently serviced via an IDE extension for VSCode. We aim to expand Konveyor AI by developing an IntelliJ plugin. Our first step involves integrating the static code analysis tool, analyzer-lsp, into the IntelliJ plugin. We plan to create a common module for interaction with analyzer-lsp, which can be used in multiple IDE plugins, starting with VSCode and IntelliJ. Currently, the IntelliJ IDE uses the Konveyor CLI tool, Kantra, for analysis and transformation, but we need to replace Kantra with analyzer-lsp to optimize real-time updates. Expected Outcome: Define and implement a new module or library to facilitate integration of analyzer-lsp into multiple IDEs. We will start with VSCode and IntelliJ to begin.

TBA
Proposal

Port Qt Quick Controls Calendar widget to Qt Quick Controls 2 module

intermediate
Open Technologies Aliance - GFOSS•2019Varies175h (Medium)

<p>Brief Explanation</p> <p>Qt is an open source cross platform framework facilitating GUI applications development, for mobile, desktop and embedded devices. Although the framework is written in C++, it brings with it a meta-language (or modelling language), QML. To accelerate UI development, QML provides the Qt Quick Controls module with ready made widget types, each supported by a C++ class, like Button or Switch, ready to be styled and modified at our project needs. The module is currently on version 2.4 but there is no support for Calendar in the latest version, to be more specific, the Calendar was lastly provided in version 1.4 of the Qt Quick Controls module that was released with the Qt 5.3 version.</p> <p>Expected Results</p> <p>The Qt Calendar widget is updated, modified accordingly and ported into Qt 5.12 and Qt Quick Controls 2 current version following the QtQC2 module standards and supporting all features like styling. The Calendar, ideally would have a Template type where from properties like background and/or contentItem can be set for style customisation &amp; switching support. Also, it should be possible to be instantiated as a standalone QML type and be styled locally for regular usage.</p>

pythonjavascriptgtk+2
Student: Spyridon Stravoravdis
Code

Utilize second order derivatives from Clad in ROOT

intermediate
CERN-HSF•2021Varies175h (Medium)

<p>In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation.</p> <p>ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations. ROOT has a clang-based C++ interpreter Cling and integrates with Clad to enable flexible automatic differentiation facility.</p> <p><code>TFormula</code> is a ROOT class which bridges compiled and interpreted code.</p> <p>The project aims to add second order derivative support in <code>TFormula</code> using <code>clad::hessian</code>. The PR that added support for gradients in ROOT is taken as a reference and can be accessed <a href="https://github.com/root-project/root/pull/2745" target="_blank">here</a>.</p> <p>Optionally, if time permits, this project will also convert the gradient function into CUDA device kernels.</p>

pythonc/c++machine learning+6
Student: Baidyanath Kundu
Code

Improved Fortran Interface Generation for PETSc

advanced
Fortran-lang•2025Varies350h (Large)

PETSc, the Portable, Extensible Toolkit for Scientific Computation, is for the scalable (parallel) solution of scientific applications modeled by partial differential equations (PDEs). Besides its native API in C it has bindings for Fortran and Python. PETSc also contains TAO, the Toolkit for Advanced Optimization, a software library supporting MPI and GPUs through CUDA, HIP, Kokkos, or OpenCL. While most of the Fortran interfaces can be generated automatically from the C-API, functions with "complex" arguments such as procedure pointers, pointers to arrays, and strings require the manual creation of interface code on both the C and the Fortran side. Moreover, due to the discrepancy of features between C and Fortran, a one-to-one translation of APIs leads to Fortran interfaces that don't leverage the capabilities of modern Fortran. Examples include overloaded functions for different types in Fortran, for which a C-API requires VOID and an explicit type argument and arrays, for which the length is part of the type definition in Fortran but requires a second argument in the C-API. This project aims to improve the automation of generating Fortran interfaces by leveraging modern Fortran features such as BIND(C) and ISO_C_BINDING along with annotation strategies to reduce the need of manual generation of interfaces. The improved system will enhance both usability for end-users and maintainability for developers.

pythonc/c++llvm+3
Student: Tapashree Pradhan
Code
Proposal

Project Proposal Geant4-FastSim - ML pipeline optimization using Kubeflow

advanced
CERN-HSF•2022Varies350h (Large)

This is the tentative proposal submission for the Geant4-FastSim - Building an ML pipeline for fast shower simulation. This proposal discusses a detailed approach to implementing the Kubeflow End to End Pipeline for the existing framework. The proposal consists of a synopsis discussing how the proposed approach was thought and what were the key insights that motivated the steps mentioned. It further discusses the task that will be encountered throughout the Project timeline and the Major Deliverables that would mark the completion of the project. The Major tasks have been visited in detail in the proposal and these are used to determine the objectives for the weekly progress timeline in the project. The proposal tries to cover up all the adopted methodology's significant detail and come up with the most ideal way to tackle each and every task. Deliverables: End to End Deployed ML Pipeline on Kubeflow Meta Logger component throughout the pipeline to store and analyze the results Experimenting with existing and new algorithmic approaches that might improve the performance, throughput of the modeling pipeline Creation of a connector component for the transition from training phase into the inference phase. Iterative development of the Pipeline into a generalized workflow that is capable of scaling to newer versions of data as well support the integration of newer algorithmic experimentation Well documented results and analysis for motivating additional focus on the pipeline as well motivating the use of this pipeline for different projects \

pythonc/c++machine learning+6
Student: Guneet Singh Kohli
Code
Showing 3025 - 3048 of 3179 Projects
125126127128129
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal