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

Reactive and Adaptive Path Planning Using Sensor Feedback and Operator Input

beginner
Open Source Robotics Foundation•2016Varies

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 →
90h (Small)

<p>ROS path planners such as MoveIt! and Descartes are good at finding feasible robot paths that avoid obstacles and optimize motion. In some applications, adjustments to nominal paths must be made based on sensor feedback or operator input. The issues were raised at ROSCON 2015 . The specific application driving this need is robotic assembly using end-effector force feedback, where parts such as computer board components need placement in holes or sockets with tight clearances, and the object locations may vary considerably with a need to locate them using vision systems. Achieving reactive and adaptive path planning may require extensions to several parts of ROS and ROS-Industrial, including the MoveIt! or Descartes path planners, the ROS control layer, or the Simple Message protocol to hardware robot controllers. Development can take place without actual force sensors or cameras, using simulated sources of the high-level outputs of these sensors in terms of small adjustments that affect the trajectories. The key software objective is to put in place a method to adjust trajectories after they have been nominally planned, rather than focusing on sensor processing.</p>

rosgazebopython+3
Student: Kentaro Wada
Code
Proposal

Simplify usage of VCF validation suite

beginner
Global Alliance for Genomics and Health•2018Varies90h (Small)

<p>vcf-validator is a suite of command-line tools that can validate and fix VCF files. The goal of my project is to overcome the limitations of the validation suite that restrict its suitability for users with a less technical, more biological profile. I would perform the following tasks:</p> <p>The suite is hard to compile for non-Linux operating systems. Gradually the user bases of Windows and MacOS X are growing, and a simple concise way of building the tool must be provided to the users. To accomplish this, I aim to simplify the build process for Windows and MacOS X.</p> <p>Currently, the suite is completely terminal-based and can only read from and write reports to local files and needs to be installed and executed in the user’s machine. To deal with this, I aim to provide a network interface to run the suite as a service that would allow users to validate their own remote files, or a dynamically generated VCF stream.</p> <p>If the input VCF is compressed, it is the user's responsibility to decompress it. My task is to reduce this extra step by making the validator itself capable of decompressing such files.</p> <p>I would investigate how to insert checksums of reference genome sequences in the VCF header.</p>

pythonjavamongodb+10
Student: Sarbjit Singh
Code

Improving Google Search Result On Buddhist Entities.

intermediate
Project WikiLoop•2021Varies175h (Medium)

<p>The Buddhist Digital Resource Center has a well-maintained database. The entities present on Wikidata often lack a label in Tibetan language. By adding a Tibetan label during the import we can dramatically improve the usability of both Google and Wikidata for Tibetan natives and community. The project will focus on various aspects of data engineering to provide the best solution to help the Tibetan community.</p> <p>Wikidata has proved to be the most efficient open source of knowledge having structured data which is extracted directly by google and affects the google search result directly. Knowledge Graphs pull in data from a variety of sources such as Wikidata. This data is used to understand user search intent and to answer search queries. The project will focus on importing data of places and persons from BDRC database, as well as the addition of new data on existing Wikidata records from BDRC. All the shortcomings present in the database will be dealt with and improved.</p> <p>Upon successful completion of this project: The Tibetan community members will be able to get better search results. The labels added will result in efficient use of Wikidata for the members of the community.</p>

pythonjavamediawiki
Student: Paritosh Singh
Code
Proposal

Enhancing the Plotting Functionality in MCnet/Rivet

beginner
CERN-HSF•2021Varies90h (Small)

<p>Rivet is a tool used by particle physicists to test and develop Monte Carlo event generators, i.e., simulation of particle accelerator collisions. Simulations are crucial for particle physics research, since they can be used to compare theoretical predictions with experimental measurements to discover new physics.</p> <p>Visualizing the output is a fundamental part of Rivet, as a good visualization makes it intuitive and easy to understand the results. Currently, plots are created by generating and compiling <code>LaTeX</code> commands. While this method does create high-quality plots, it can be slow, have memory issues, be sensitive to the deployment platform.</p> <p>The goal of this project is to solve the above mentioned issues by replacing the <code>LaTeX</code> plotting backend with a new high-level API that can support multiple rendering backends. The API should make it easy to export high-quality plots, while still allowing full customization for advanced users. <code>Matplotlib</code> will become the first rendering backend that will be added to this API, and options for exporting figures into interactive plots in the browser will also be investigated.</p>

pythonc/c++machine learning+6
Student: Simon Thor
Code
Proposal

New releases for atleast 25 Sugar Activities

intermediate
Sugar Labs•2020Varies175h (Medium)

<p>Sugar has a lot of activities, with 250+ on GitHub, and more elsewhere. These have scope for improvement; bugs, features, updated human translations, and release. There are many activities which have not been maintained or updated for over a decade. It is important to port such activities from python 2 to python 3 along with porting them to Gtk+3. The support for python 2 is being withdrawn and the port to Gtk +3 to have a fully functional activity is important. Inaddition to that, the activity might require porting</p> <ul> <li>from GObject to GLib</li> <li>from GConf to Gio.settings</li> <li>from GStreamer Gst.Message.structure to get_structure()</li> <li>and porting to TelepathyGLib</li> </ul> <p>My project also includes adding feature improvements or fixing the features of the activity which are not working and fix display resolution issues. I will be collaborating with others to prepare activities for release and also test debian packages if needed. It is important to identify if the tracebacks are due to activity code, changes in versions of packages or due to difference in the test environment.</p> <p>So this project aims at making necessary changes to sugar activities to have at least 25 release ready activities.</p>

pythonjavascriptgtk++10
Student: Jui Pradhan
Code
Proposal

[DaCe-Debug] Retaining Semantic Source Information in Dataflow Representations

advanced
Scalable Parallel Computing Laboratory•2024Varies350h (Large)

The DaCe framework uses the Stateful DataFlow multiGraph (SDFG) data-centric intermediate representation. This graph maps to a variety of high-performance architectues and performance engineers can manipulate this graph for achieving state-of-the-art representations. When dealing with large projects with hundreds of thousands lines of codes the state graph can become extremely unreadable due multiple nested cycles, function’s calls, and conditional branching: it becomes nearly impossible to understand smaller parts of the graph and it also makes relating it to the original source code very hard. To mitigate this problem the concept of ControlFlowRegion was introduced. A ControlFlowRegion is a region of the SDFG which represents a control flow construct just like a traditional programming language. An example can be the LoopRegion, developed on a separate feature branch (loop_architecture_pt_3), which represents the classic C-like for loop for ( init-clause ; cond-expression ; iteration-expression ). The project goal is to - Implement all the other control flow constructs like if … elif … else and match - Implement regions for function calls and with statements - Implement user defined regions - Add support for all these new regions in the DaCe VSCode extension

pythonc++mpi+2
Student: luca-patrignani
Code

Machine Learning in Julia for Calorimeter Showers

intermediate
CERN-HSF•2024Varies175h (Medium)

The calorimeter, a key detector in Large Hadron Collider (LHC) experiments, measures the energy of particles interacting with detector materials. Particles emerging from collisions create cascades of secondary particles, or showers. Describing these processes requires precise simulation methods like the Geant4 toolkit. Machine learning (ML) techniques, such as generative modeling, offer a promising alternative. Recently, the Fast Calorimeter Simulation Challenge (CaloChallenge) spurred the development and evaluation of different models. Also, in High-Energy Physics (HEP), there has been an increasing interest in using Julia as a language for software development, for combining the ease of programming of interactive languages, e.g. Python, with the speed of compiled languages, e.g. C++. This project targets to assess Julia's machine learning ecosystem's maturity, in terms of availability and robustness of libraries and tools for deep learning. To this end, a selection of models from the CaloChallenge will be chosen for implementation in Julia, as well as the required functionality to enable training and evaluation of the networks. Ultimately, a comprehensive analysis will be conducted between Python/C++ and Julia implementations, considering training time, inference time and evaluation metrics from CaloChallenge.

pythonc/c++machine learning+6
Student: Daniel Regado
Code
Proposal

Continous-Time Collision Detection for CGAL

intermediate
CGAL Project•2023$3k–$6.6k175h (Medium)

Funded by GSoC this summer, I propose to add collision detection to CGAL in a way that naturally builds on and extends CGAL’s existing AABB-tree functionality. The project will focus on implementing trusted collision-detection methods, which are attested to by their use in projects like the Godot game engine as well as their continued academic propagation through works like Ericson’s “Real-Time Collision Detection” and courses like UT Austin’s “CS395T: Physical Simulation”. I envision the project having the following deliverables: - Modifications to CGAL’s existing AABB tree functionality where necessary, e.g. to handle moving bounding boxes and dynamic restructuring of the bounding volume hierarchy - Broad-phase collision detection routine that utilizes CGAL’s AABB tree to quickly rule out unnecessary collision queries and identify potential collision pairs - Narrow-phase collision detection routine that performs fast collision tests on the pairs of primitives identified in the broad phase - Tests to cover all changes and new functionality - Documentation of the above The full proposal can be found here: https://hackmd.io/@1V1uNkwcQMiMbp_OanOjUA/r1kG1v_-3

githubc++git+4
Student: Jeffrey.D.Cochran
Code
Proposal

Service Queues

advanced
OpenMRS•2026Varies350h (Large)

The OpenMRS O3 Service Queues app manages outpatient clinic flow but suffers from performance issues due to over-fetching deeply nested objects via custom REST representations, UI components that diverge from O3 design conventions and broken interactions including non-functional buttons and silent failures. This project builds a dedicated REST endpoint in openmrs-module-queue following the emrapi PR #250 pattern, returning only the data the queue table needs with server-side pagination and batch loading. Visit details are lazy-loaded on row expansion. On the frontend, the custom vitals component is replaced with the shared patient-vitals-info extension, encounter parsing is standardized to use configurable concept UUIDs and SWR data-fetching is optimized with activity-aware revalidation. All broken buttons are either fixed or removed. Deliverables include the dedicated backend endpoint with database indexes, frontend migration with lazy-loaded visit details, UI alignment with O3 conventions, fixed interactions with proper error handling, activity-aware SWR optimizations and comprehensive Playwright E2E tests with before/after performance benchmarks.

javahtml5groovy+11
Student: UjjawalPrabhat
Code
Proposal

Automated Release Pipeline for Music Blocks

intermediate
Sugar Labs•2026Varies175h (Medium)

Music Blocks currently relies on a manual and irregular release process, which leads to deployment delays, higher risk of human error, and limited visibility into application health. This project aims to modernize the release workflow by introducing a fully automated, reliable, and auditable CI/CD pipeline. The solution will involve designing and implementing automated deployment workflows integrated with existing CI, enabling seamless releases from the main branch. Key improvements include semantic versioning and automated changelog generation, Docker-based builds published to GitHub Container Registry, and a multi-environment setup with staging and production. The pipeline will incorporate preview deployments, approval gates, and pre/post-deployment validation to ensure safe and consistent releases. Additionally, rollback mechanisms, monitoring, and deployment notifications will be added to improve reliability and observability. The final deliverables will include a complete CI/CD pipeline, containerized deployment setup, automated versioning and changelog system, staging and production environments with deployment workflows, rollback and validation mechanisms, monitoring and alerting integration, and comprehensive documentation with runbooks and troubleshooting guides.

pythonjavascriptgtk++10
Student: Sonal Gaud
Code
Proposal

3D Jupyter Notebooks and WebGL Integration for OpenVINO

beginner
OpenVINO Toolkit•2022Varies90h (Small)

We usually need visualization, in fact, to enhance the interpretability of data or results, and facilitate the understanding of developers and users. In machine learning, 3D or 4D representation provides more depth information than the 2D representation, many of the tasks may be much better understood if we provide a 3D or 4D. But OpenVINO has no native real-time 3D visualization engine or library. This can be very troublesome for users who use display 3D images. So our goal is working natural 3D support for Jupyter Notebooks running OpenVINO (AI inference). There are a few solutions in Jupyter 3D graphic display, though: 1. Requires complex setup, build or is not friendly to the average user (without graphics programming experience) 2. Not integration with OpenVINO(Need process different data and different inference results available from OpenVINO, the user only needs a simple interface to set this up) The project idea aims at fill in the gaps mentioned above: 1. Provides a clean interface to set up the display of these graphics without the need for a graphical programming background(beginner-friendly) 2. 3D support for Jupyter Notebooks running OpenVINO(Be able to transform and process the output data of OpenVino)

pythonc++x86+1
Student: Ran Piao
Code
Proposal

Large Social Network Analysis and Anomaly Detection with Augur

intermediate
CHAOSS•2020Varies175h (Medium)

<p>Augur is a software that collect data for a list of given repositories and provide a variety of CHAOSS metrics to provides open source health and sustainability metrics.Then users can empirically investigate and uncover useful insights for software engineering, such as understanding the collaborative pattern.</p> <p>In the current stage, Augur is unable to mining the repositories to generate the co-editing information in the open source software development. This project idea is about to develop this kind of functions to enhance the Augur project. It will end up with a new data worker and analysis tool for fine-grained co-editing network which opens up a massive new source of high-resolution data on human collaboration patterns.</p> <p>Then I would like to establish the Augur server to mining and monitor the open source ecosystem (with 10000+ repositories or more). The collaboration networks and social trace data of all contributors in the open source ecosystem will be evaluated in terms of social network analysis. It will play a vital role in achieving Augur's goal towards analysis of open source organizations health as well as the goal of the CHAOSS project towards diversity and inclusion.</p>

pythonmysqljavascript+8
Student: Tianyi Zhou
Code

Reverse-mode automatic differentiation of GPU kernels using Clad

intermediate
CERN-HSF•2024Varies175h (Medium)

Nowadays, the rise of AI has shed light into the power of GPUs. The notion of General Purpose GPU Programming is becoming more and more popular and it seems that the scientific community is increasingly favoring it over CPU Programming. Consequently, implementation of mathematics and operations needed for such projects are getting adjusted to GPU’s architecture. Automatic differentiation is a notable concept in this context, finding applications across diverse domains from ML to Finance to Physics. Clad is a clang plugin for automatic differentiation that performs source-to-source transformation and produces a function capable of computing the derivatives of a given function at compile time. This project aims to widen Clad’s use range and audience by enabling the reverse-mode automatic differentiation of CUDA kernels. The total goal of the project is to support the differentiation of CUDA kernels that may also include typical CUDA built-in objects (e.g. threadIdx, blockDim etc.), which are employed to prevent race conditions, using Clad. These produced kernels will compute the derivative of an argument specified by the user as the output based on an input parameter of their choosing. In addition, the user must be able to call these kernels with a custom grid configuration.

pythonc/c++machine learning+6
Student: Christina Koutsou
Code

VRP functionality with VROOM on the database for pgRouting

intermediate
OSGeo (Open Source Geospatial Foundation)•2021Varies175h (Medium)

<p>The project aims at implementing the VRP functionality in the <a href="https://github.com/pgRouting/vrprouting/" target="_blank">vrprouting</a> repository of pgrouting, using VROOM as a library in C++.</p> <p><a href="https://github.com/VROOM-Project/vroom" target="_blank">VROOM</a> is an open-source optimization engine, that aims at providing good solutions to well-known Vehicle Routing Problems (VRP), such as:</p> <ul> <li>TSP (Travelling Salesman Problem)</li> <li>CVRP (Capacitated VRP)</li> <li>VRPTW (VRP with Time Windows)</li> <li>MDHVRPTW (Multi-Depot Heterogeneous VRPTW)</li> <li>PDPTW (Pickup-and-Delivery Problem with TW)</li> </ul> <p>Implementing the VROOM functionality as a PostgreSQL function will be very beneficial to those users who want to use the VROOM functionality directly from the database. Users can use it to solve real-world vehicle routing problems efficiently, as VROOM provides a good solution to well-known vehicle routing problems within small computing times, and it can scale to handle very big instances.</p>

pythonjavascriptc/c+++4
Student: Ashish-Kumar
Code

SimTools: Output Analysis for Monte Carlo

beginner
R project for statistical computing•2023Varies90h (Small)

I propose completing the R package "SimTools" before it's ready for CRAN submissions. To equip the user with almost all types of output analysis of MCMC, SimTools is here. SimTools is an R package (not completed) that provides users with an enriched analysis of MCMC simulations (also iids) and facilitates the generation of Markov Chains. This project shall affect both beginners and well-experienced users. More examples of how to write complicated simulation and analysis methods will help beginners, and they will be able to use the models in their projects directly. Importing simulated chains from other libraries will help the experienced users perform transfer learning on their Simulated Markov Chains. This tool provides a range of MCMC algorithms and diagnostic tools to help users evaluate the performance of their models. As the Package is Partially developed, I need to implement six significant tasks to complete this package(Reference - Project webpage). These tasks are Improving Multiple chain compatibility, Implementing Summary function for output, Compatibility for discrete state space Markov Chains, Efficient trace plots, Export to C++(CI Calculations), and Rich Documentation of the Package. I have already gone through all these problems and developed possible approaches to solve them.

cc++r+4
Student: Siddharth_Pathak
Code
Proposal

Fine-tuning Vision-Language Models for Object Detection and Hierarchical Classification

advanced
OpenVINO Toolkit•2025Varies350h (Large)

This project aims to fine-tune Vision-Language Models (VLMs) for domain-specific tasks like object detection and hierarchical classification, focusing on real-world applications in fields such as medical diagnostics and biodiversity monitoring. Although VLMs like BLIP-2 and TinyCLIP show strong general-purpose performance, their effectiveness diminishes in specialized domains due to domain shifts, hierarchical label structures, and hardware constraints. To address this, we will implement efficient fine-tuning strategies—including LoRA, QLoRA, and adapter tuning—within the OpenVINO Training Extensions (OTX), enabling scalable training on consumer-grade GPUs. We’ll enhance these models with support for structured prediction and deploy them using OpenVINO’s quantization and optimization toolchain, ensuring fast, lightweight inference across devices. Beyond technical contributions, the project delivers practical tools and open-source pipelines that bring advanced multimodal AI to resource-limited environments. By supporting transparent, efficient deployment of VLMs in impactful domains, this work bridges cutting-edge research with high-value, real-world use cases.

pythonc++x86+1
Student: Jiayu Li
Code

Modernize search storage format for the MusicBrainz database

advanced
MetaBrainz Foundation Inc•2026Varies350h (Large)

The MusicBrainz database has a Solr search engine used for both website search and search API. MB Search architecture for reference. After solr was upgraded to version 9, the schemas in configsets weren’t updated and still use version 1.5. They need to be upgraded to version 1.7. Solr currently keeps data in index fields for search and also uses _store field to store the index field data + other non index field’s data for response writer, causing redundancy. To eliminate this redundancy, we need to store all the required data in the fields themselves. Solr response writer currently reads all the data from _store field of a document and returns it in a valid MB XML/ MB JSON format. After modifying the configsets and indexer to store data in the fields, we need to create response writers that read from these fields and return data in a valid MB XML/ MB JSON format, along with validation tests for these writers. Since storing data in individual fields rather than a single _store blob will lead to change in performance,we will start with the artist core and benchmark it before rolling out to all remaining entities.

pythonjavascriptperl+8
Student: junaid_
Code

Rucio WebUI Revamp

advanced
CERN-HSF•2025Varies350h (Large)

As a final-year Software Engineering student at Kyiv Polytechnic Institute, I propose transforming Rucio WebUI into a more powerful, intuitive, and sustainable platform. Drawing from my previous contributions and technical expertise, I've developed a comprehensive strategy that addresses current limitations while setting the foundation for future growth. My plan focuses on migrating to modern technologies (Next.js 15, React 19, TailwindCSS 4.x), implementing server-side rendering for improved performance, enhancing the authentication system with NextAuth.js and RBAC, and fixing critical bugs like DID slash-handling issues and non-functional replicas loading. I'll also optimize performance through advanced streaming mechanisms for large data volumes, improve architecture with a transition to NX monorepo, enhance entity management functionalities, and implement comprehensive UI/UX refinements. With substantial experience in the Rucio WebUI codebase from my previous internship and 30+ contributions to the project, I've demonstrated my commitment and technical ability to execute this comprehensive modernization plan. My current work with Next.js and NX at a startup provides me with cutting-edge expertise that I can directly apply to enhance the project's development and implementation.

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

Implement JS filesystem bridge layer for Emscripten

advanced
Chromium•2023Varies350h (Large)

Emscripten is an open-source tool used to translate C/C++ code to WebAssembly, allowing web apps to run with near-native performance. WebAssembly is especially popular for web games and other performance-oriented applications. As of March 2023, Emscripten uses an emulated file system written in JavaScript to support C/C++ file system operations in compiled WebAssembly code. Currently, the mentors are working on WasmFS, an emulated file system built in C++/WebAssembly, for Emscripten. However, WasmFS lacks the JavaScript required to connect the existing JS API to the new C++/WebAssembly file system operations. The central goal of this project is to build a new JavaScript library modeled after Emscripten’s existing file system library that will call WasmFS functions instead of JavaScript routines. This approach aims to speed up filesystem operations and lay the foundation to add multithreading in the future. That being said, this project does not aim to redesign the filesystem implementation for Emscripten. This project also will not add new functionality to the Emscripten file system. Finally, this project will not attempt to add full multithreading functionality yet.

pythonjavascriptjava+2
Student: James Hu
Code
Proposal

Apache NuttX Apps and Rust Integration

beginner
Apache Software Foundation•2024Varies90h (Small)

The integration of Rust into Apache NuttX, an embedded Real-Time Operating System (RTOS) used across various platforms from 8-bit to 64-bit, aims to enhance the security and reliability of IoT applications. Rust, known for its safety and memory integrity, is seen as a promising solution to address vulnerabilities in IoT systems, such as buffer overflows and memory corruption. The project involves studying Rust for embedded systems and "no_std" environments, creating coding guidelines for Rust in NuttX, and developing a guide for these standards. It starts with converting simple NuttX applications, like the LED Blinky App, to Rust, gradually moving to more complex applications. The deliverables include implementing Embedded Rust, C Interoperability, and Heap Memory Allocation in Rust, porting the LED Blinky App from C to Rust, and testing it on various Single-Board Computers. The project also aims to merge these items into NuttX Mainline as Pull Requests and add workarounds for NuttX's rustc build process. Documentation will cover a coding standard for Rust, setting up a local environment for Rust build, configuring NuttX to work with Rust, and building Rust firmware with NuttX.

pythonjavascriptjava+7
Student: Rushabh Gala
Code
Proposal

Automated Security Assessment Infrastructure for LibreHealth EHR Workflows

intermediate
LibreHealth•2026Varies175h (Medium)

LibreHealth EHR manages sensitive patient data but currently has no automated security testing or vulnerability detection integrated into its development workflow. This means security issues like SQL injection, cross-site scripting, and broken access control can go undetected during code reviews. This project builds a four-layer automated security assessment pipeline integrated directly into the CI/CD workflow. The pipeline consists of a static analysis stage using PHPStan, Enlightn, and Composer Audit to catch code-level vulnerabilities; a dynamic testing stage using OWASP ZAP to simulate real-world attacks against a running EHR instance; a custom CVSS scoring engine that adjusts risk scores based on PHI sensitivity of the affected data; and a security gate that automatically blocks merge requests when high-severity vulnerabilities are detected. The key deliverables are a Meaningful Use workflow security test suite covering 7 clinical workflows, a fully configured GitLab CI pipeline, an automated security gate with PHI-aware scoring, and per-build HTML, JSON, and CSV security reports for both humans and machines.

mysqljavascriptjava+6
Student: Kishan Singh 07
Code

Apache Fory C++ & Rust gRPC Integration

advanced
Apache Software Foundation•2026Varies350h (Large)

Apache Fory provides high-performance serialization & deserialization and code generation from IDL, but it currently lacks end-to-end gRPC service integration for C++ and Rust. As a result, developers may still need to rely on external toolchains (e.g. protoc/prost) to generate service bindings, which prevents Apache Fory from being used as a complete gRPC solution. This proposal aims to enable Apache Fory to generate gRPC-compatible client and server code for both C++ and Rust, while reusing the existing gRPC runtimes (gRPC C++ and tonic). The core idea is to extend the Apache Fory compiler to generate service stubs and integrate Fory's serialization & deserialization into the gRPC pipeline by replacing the default codec (protoc and prost). The design decouples API definitions from transport- layer bindings and introduces reusable codec implementations. The project will also include comprehensive testing (unit, differential, and cross-language), CI integration, and documentation. This work will make Apache Fory a practical alternative to existing protobuf-based toolchains in gRPC frameworks and provide a reference architecture for adding gRPC support to other languages in the future.

pythonjavascriptjava+7
Student: Peiyang He
Code
Proposal

Using Pseudo-random number repeatably in a fine-grain multithreaded simulation

intermediate
CERN-HSF•2017Varies175h (Medium)

<p>Particle transport Monte Carlo simulations are a key tool for High Energy Physics experiments, including the LHC experiments at CERN. All Monte Carlo (MC) simulations depend vitally on Pseudo-Random Number Generators (PRNGs) used to sample many distributions. Each LHC experiments generates 5-10 Billion sampled physics events a year using around 10^18 sampled values from PRNGs. PRNGs take 1-5% of CPU time. PRNGs used must possess very large periods, fast execution, the ability to create a large number of streams, and very good correlation properties between streams and sampled values. It must be possible to reproduce a simulated event any time, for reexamination or debugging. The transition from event-level parallelism in Geant4 to dynamical multithreading in GeantV requires associating the random generator states not with the threads but with the tracks, which are shuffled between "baskets" based on their type and energy. Maintaining reproducibility after such transition requires a drastic change in the way the random generators are used. We suggest solutions based on Scalable Pseudo Random Number Generators and on pedigrees introduced in CilkPlus, which are first tested in Geant4.</p>

pythonc/c++machine learning+6
Student: Dima Savin
Code

AI Fictional Travel Itinerary Generator for LG

intermediate
Liquid Galaxy project•2024Varies175h (Medium)

Planning a vacation can be quite a task. One of the challenges is finding some engaging details about destinations to explore. Often when we look into places to visit, we come across a range of options, which may result in making incorrect decisions and overspending. This situation can be disheartening for travelers like me. That's why there should be a method that enables us to explore travel spots, with just one prompt. Such a system would enhance the experience of planning a trip making it more delightful and fulfilling. Resolving this I came up with a tool (A Flutter App) that helps users plan travel adventures. By using one of the fastest Generative text AI models, Groq, it builds exciting tales of travelers exploring specific Points of Interest (POIs) selected by the user. The app creates a storyline around sub-POIs. Using the LG Rig the app presents the story in paragraphs each focusing on a sub-POI for a visually immersive experience. It also suggests tour recommendations on the screen to keep users engaged. And the Use cases of this tool is not just limited to travelers but also in education. Additionally, our app includes an accessibility feature to generate voice narration making sure all users can enjoy the experience.

javascriptrosgis+14
Student: Rohit_Kumar_
Code
Proposal
Showing 3673 - 3696 of 3883 Projects
152153154155156
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal