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

Playlists Sorting and Organization

intermediate
MetaBrainz Foundation Inc•2026Varies

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)

This project aims to improve playlist management in ListenBrainz by making it easier for users to search, organize, and interact with their playlists. Currently, while some backend support exists, the user experience lacks intuitive features for managing personal playlists effectively. To address this, I plan to implement four main features. First, I will complete and enhance playlist search directly on the user playlists page. Second, I will introduce tag-based organization, allowing users to categorize and filter playlists efficiently. Third, I will add in-playlist track sorting options such as sorting by title, artist, date added, and shuffle. Finally, I will enable users to view their MusicBrainz collections as playlists and optionally save them within ListenBrainz. The project will involve backend changes such as adding new database tables and API endpoints, along with frontend integration using React to provide a smooth and consistent user experience. The final deliverables will include a fully functional playlist search feature, tag-based organization system, track sorting functionality, and MusicBrainz collection integration, along with tests and documentation for all components.

pythonjavascriptperl+8
Student: Yateen Dogra
Code
Proposal

Behavior Metrics and Deep Learning Studio: Developing and Deploying Deep and Reinforcement Learning for Multiple-Robots

intermediate
JdeRobot - Universidad Rey Juan Carlos•2021Varies175h (Medium)

<p>Behavior Metrics comprises a wide range of robots with the pipeline completely set for various Deep Learning and Reinforcement Learning (RL) setups. With its main concern over the racing track, the Formula 1 (F1) setting solves the line following objective well. However, the presence of 2 separate pipelines for RL and DL is confusing to the users. The DL base works on the JDERobot app, while the RL base takes the privilege of gym-gazebo. These two bases are unable to communicate with each other. Also, the current framework does not leverage the full capabilities of testing scenarios and robots. Apart from line-following, F1 racing for autonomous maneuvers and drone racing has gained much popularity. Although these settings are highly derivative, it requires few significant changes in the control architecture and modularity wrt multiple robot settings. This project’s primary goal is to move towards more extensive support and documentation of Behavior Studio to suit the same RL environment or DL brain to multiple robots with continuous control integration. The advantages of such changes will make the framework more user-friendly and adaptive to various tasks and robot settings.</p>

pythonc/c++ros+4
Student: Utkarsh A. Mishra
Code

Enhancements to the ECEB App Based on User Study

intermediate
LibreHealth•2023Varies175h (Medium)

The Essential Care for Every Baby (ECEB) mobile application is designed to offer clinical decision support to healthcare personnel who provide essential care interventions for newborns. The project aims to improve the user experience, accuracy, and reliability of the app by revamping its user interface, improving the rule-based classification algorithm, resolving syncing issues on local storage and the DHIS2 rule engine, enhancing the app's functionality, and developing user manuals and training materials. The project will be implemented in four phases using Agile Development Methodology. The first phase will revamp the application based on UX changes, the second phase will improve the rule-based classification algorithm, the third phase will address DHIS2 rule engine and syncing issues, and the fourth phase will focus on documentation. The enhancements proposed in the design include making the application more accessible and user-friendly with more visual cues, legible fonts, and features that increase functionality. The goal is to ensure that healthcare workers in low and middle-income regions have essential knowledge, skills, and competencies to deliver life-saving care to newborns.

mysqljavascriptjava+6
Student: Akash Srivastava
Code
Proposal

GraphSpace: Git for graphs

intermediate
National Resource for Network Biology (NRNB)•2018Varies175h (Medium)

<p>GraphSpace is a web-based platform where collaborating research groups can use a user-friendly interface to create, interact and share networks. Users can upload richly-annotated networks using REST APIs irrespective of the algorithms or tools used in the creation of the graph. Cytoscape.js enables the users to interact with the graphs using a graphical user interface. Users can customize the layouts of the graph, search for graphs matching some criteria, organize using tags, save the graph, and share them between collaborating groups or make it available to everyone in Graphspace.</p> <p>The goal of this project is to implement a system of version control which will enable users to track changes made to the graphs, save different version of the graph with detailed summary of the changes with respect to previous version. The user will be able to undo changes and backtrack to a previous version of the graph using GUI and REST APIs. A layout created for a particular version of a graph may not be compatible with other versions of the same graph, therefore a feature will be added to check layout compatibility and to transfer layout between different versions of a graph.</p>

pythonjavascriptjava+11
Student: Daniyal
Code
Proposal

Implementing biodiversity data checks for the bdchecks package

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

<h3>Background</h3> <p><a href="https://bd-r.github.io/The-bdverse/bdchecks.html" target="_blank"><em>bdchecks</em></a> is an infrastructure for performing, filtering and managing various biodiversity data checks using R. Data checks are a key to promoting biodiversity data quality. <em>bdchecks</em> offers various features for different types of R users:</p> <ul> <li>An interactive and user-friendly Shiny app for inexperienced R users.</li> <li>Full command line functionality for more experienced R users.</li> <li>Advanced R users can easily edit, add and manage their own collection of data checks, using one single YAML file and only two supporting R functions.</li> </ul> <p>Improving the quality of biodiversity research, in some measure, is based on improving user-level data cleaning tools and skills. Adopting a more comprehensive approach for incorporating data cleaning as part of data analysis will not only improve the quality of biodiversity data, but will impose a more appropriate usage of such data.</p>

cc++r+4
Student: Povilas Gibas
Code

Folksonomy Engine: a one size fit all for any product data

beginner
Open Food Facts•2025Varies90h (Small)

The Folksonomy Engine does not support intuitive property suggestions and reusable web components. In order to enhance usability and scalability, the system requires improved property suggestion mechanisms, more effective handling of nested values, and an easier-to-use interface for data contribution and analysis.\n \n To address the challenges in data contribution, consistency, and exploration, the project will develop new API features and create a reusable web interface. The proposed solution includes developing new API features and a reusable web interface. The main goal is to get as many contributors as possible to use this, making it easy and accessible for everyone to contribute.\n \n New API Features:\n - Suggestions based on popularity and categories\n - Adding User roles\n - Improved handling of nested property values\n - Adding moderation for bulk property, value management\n - Tools for exploring and merging values\n \n Improved Reusable JavaScript-based Web Interface:\n - For display and editing of data\n - Integrating folksonomy-editor to main project\n - Potential formalization of property definitions

androidmachine learningmongodb+6
Student: Kirtan Chandak
Code

Large-scale computing backend for Jupyter notebooks - HTCondor batch job submission and monitoring using the Ganga toolkit

intermediate
CERN-HSF•2018Varies175h (Medium)

<p>Jupyter Notebook is an interactive computing environment that creates notebooks which contains computer code as well as rich text elements like equations, figures, plots, widgets and theory. Ganga is an open source iPython based interface tool to the computing grid which leverage the power of distributed computing grid and provide scientists an interface supported by a powerful backend where they can submit their computation intensive programs to Ganga as a batch job. HTCondor is a workload management system created by University of Wisconsin-Madison. It is based on High-Throughput Computing which effectively utilizes the computing power of idle computers on a network or on a computing grid and offload computing intensive tasks on the idle machines available on a network or computing grid. This project aims to create a plugin for Jupyter Notebook and also integrate it to SWAN Notebook service which is a cloud data analysis service developed and powered by CERN. This plugin will easily submit and monitor batch computation jobs to HTCondor using Ganga toolkit. The plugin will display status of ongoing job in Notebook itself and will also allow termination of ongoing jobs.</p>

pythonc/c++machine learning+6
Student: Aman Pratap Singh
Code

OrgExplorer: GitHub Organization Analytics and Visualization System

beginner
AOSSIE•2026Varies90h (Small)

As GitHub organizations grow, it becomes difficult to understand overall activity across multiple repositories and contributors using the default interface. Important insights such as contributor involvement, repository activity, and development trends are often scattered across many pages, which makes analysis slow and inconvenient. This proposal introduces OrgExplorer, a web-based platform designed to provide a clearer view of activity within GitHub organizations. The project will collect data from the GitHub REST and GraphQL APIs, process it, and present it through an interactive and easy-to-understand interface. The system will include features such as repository and contributor insights, activity visualizations, calculated metrics, and browser-based caching to reduce repeated API requests. Support for GitHub Personal Access Tokens will also be included to enable richer data access. By the end of the project, OrgExplorer will provide an interactive dashboard with organization-level insights, repository and contributor visualizations, metrics and rankings, exportable reports (CSV and PDF), and proper documentation. The goal is to make it easier for users, maintainers, and community members to explore and understand how GitHub organizations are evolving over time.

pythonjavascriptswift+8
Student: Rahul_Vyas
Code

Automated Compilation Verification Across All Concerto Code Generation Languages

intermediate
Accord Project•2026Varies175h (Medium)

Concerto is the modeling language of the Accord Project. It supports code generation for 16 target languages and schema formats such as Java, TypeScript, Go, Rust, C#, GraphQL, and Protobuf. At present, CI only checks that the generator runs without crashing. It does not verify that the generated code compiles or validates in its target environment. This allows broken code to reach users without detection. This project adds full compilation and validation checks across all 16 targets through three deliverables. The first deliverable is a set of Docker images, one for each target. Each image includes the Concerto CLI and the required language toolchain. These images are published to the GitHub Container Registry with layer caching enabled. The second deliverable is a GitHub Actions matrix workflow. It generates code from a test corpus, runs it inside the correct image, and executes the compiler or validator for every pull request. The workflow fails immediately if the output is invalid. The third deliverable is a versioned test corpus of .cto model files. These files cover all Concerto language constructs such as primitives, optionals, arrays, inheritance, enumerations, and relationships. This ensures full coverage of code generation features.

javascriptreactcompiler+5
Student: Apoorv Gadiya
Code

Add ensembling methods for tiling to Anomalib

advanced
OpenVINO Toolkit•2023Varies350h (Large)

When tackling the challenge of detecting defects in high-resolution images, we encounter many challenges. One significant problem is the difficulty in training models effectively, primarily due to memory limitations. The process of down-sampling these images to fit within memory capacities leads to the loss of crucial information, which can result in the oversight of small yet significant defects. To overcome these issues, we can employ a strategy involving a tiled ensemble mechanism. In this case, images are split into smaller, manageable tiles. Each of these tiles is then processed using a separate model, specifically trained for that tile position. This strategy enhances localization and improves the detection of small anomalies, while also satisfying memory limitations. Anomalib currently has a basic tiler. However, the advantages of locally-aware models, like Padim, are diminished without the support of a tiled ensemble. To address this problem, we introduce a tiled ensemble implementation that preserves the advantages of local awareness while also enhancing overall performance. This approach aims to incorporate Anomalib's existing features, while simultaneously providing users the flexibility to tailor specific steps within our pipeline. All the while, we ensure that our approach remains memory-efficient.

pythonc++x86+1
Student: Blaž Rolih
Code
Proposal

Expand Microcks Hub Sandbox & Mocking for Key Industry APIs (2025 Term 1)

Intermediate
•Varies175h (Medium)

Microcks (https://microcks.io/) is a cloud native, open source tool under CNCF for API and microservices mocking and testing. This project aims to enhance the [Microcks Hub](https://hub.microcks.io/) by updating the existing sandbox environment or adding new hub entries to mock key APIs IT industry leaders use. The goal is to make it easier for developers to test and prototype integrations with popular APIs like GitHub, Twilio, Stripe, or Salesforce using Microcks. Expected Outcome: Participants can choose to focus on one or both of the following aspects: 1. Update and Refresh the Existing Sandbox: - Improve the sandbox environment provided by Microcks Hub for existing mock APIs. - Ensure compliance with the latest versions of existing APIs. - Enhance documentation, usability, and deployment mechanisms. 2. Add New Hub Entries for Key Industry APIs: - Develop mock entries for leading APIs like GitHub, Twilio, Stripe, or Salesforce, but we welcome any ideas... - Ensure the mocks cover essential endpoints and realistic request-response pairs. - Provide detailed examples and use cases to support integration testing.

TBA
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

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

Robust OpenCL Operations

intermediate
GNU Image Manipulation Program•2024Varies175h (Medium)

The massively parallel nature of many real-world computations has led to the development of specialized massively parallel hardware such as GPUs, TPUs and FPGAs. Many closely-related programming models exist such as CUDA and OpenCL. OpenCL is a popular framework for writing massively parallel code given its broader ecosystem and supported platforms. GIMP is a popular free open-source image manipulation tool often shipped as the default tool in many Unix-based distributions. GIMP uses GEGL internally for accelerating various image processing tasks. GEGL comes with OpenCL implementations for many operations. However, the OpenCL backend in GEGL was often slower than the baselines and resulted in incorrect outputs (and crashed sometimes). The goal of this project is to enumerate all the existing OpenCL implementations in GEGL, write a thorough suite of tests for them, and fix as many implementations as possible. If time permits and once correctness is established via tests, the project adds new faster implementations for popular operations. A successful completion of the project would allow the OpenCL backend to be enabled by default and allow the end-users to take advantage of hardware acceleration on their devices automatically.

cGEGL
Student: Varun Samaga B L
Code
Proposal

CAPA Reimagining how we handle AWS account preparation

Intermediate
•Varies175h (Medium)

Description: Cluster API Provider AWS (CAPA) can create and manage the lifecycle of Kubernetes clusters in AWS (with the help of Cluster API in general). For each target AWS account where a user wants to create clusters it must be prepared for usage first. This is currently done using [clusterawsadm](https://cluster-api-aws.sigs.k8s.io/topics/using-clusterawsadm-to-fulfill-prerequisites.html) which creates/updates a CloudFormation stack that in turn creates/updates IAM resources. This approach has caused issues as CloudFormation is region specific but IAM is global and users often run the tool in different regions which results in failed stacks that cannot easily be deleted. As a project we want to move away from using CloudFormation and instead use API calls (like the rest of CAPA). We also want to make the process idempotent so it doesn't matter if you run it against different regions. This account preparation is key to CAPA and with out it CAPA cannot run. Expected Outcome: A new approach to handling the prerequisites required for CAPA. We need to continue to support the cli based approach (so clusterawsadm will be updated) but we can also explore a declarative approach with an operator.

TBA
Proposal

Implement Jupyter Extension and Desktop App for Airavata MFT

advanced
Apache Software Foundation•2024Varies350h (Large)

Currently, Airavata MFT can be accessed through its command line interface and the gRPC API. However, its accessibility will be really enhanced if a Docker desktop-like application and a JupyterLab-S3-Browser-like Jupyter extension are provided for locally running Airavata MFT. Some proposed features for the app and the extension are: - Start / Stop MFT Instance - Register/ List/ Remove Storage endpoints - Access data (list, download, delete, upload) in configured storage endpoints - Move data between storage endpoints - Search data across multiple storage endpoints - Analytics - Performance numbers (data transfer rates in each agent) We will use Electron to develop the desktop app. The Node.js backend of Electron will connect to Airavata MFT using gRPC to perform management operations. We will first develop an Airavata MFT Node SDK similar to the existing Python SDK. The Electron app and the Jupyter extension will then be built on top of this Node SDK. Publishing the SDK as a stand-alone npm package will also open possibilities for building new tools using Airavata MFT in future.

pythonjavascriptjava+7
Student: Shivang Mishra
Code

Modeling Wayfinding

intermediate
Red Hen Lab•2024Varies175h (Medium)

Stentor roeselii is a free-living ciliate species of the genus Stentor. It is a unicellular organism but shows remarkable hierarchy of decisions when faced with a stimulus leading us to question whether there is some level of cognition involved and whether the line between metabolism and cognition is fuzzy implying mitochondria may be the cognitive centre For the last 200 years research into human cognition and decision-making has revolved around rational choice theory, which assumes that actors are utility maximizers capable of searching and finding rational and optimal decisions. However human behavioral data doesn’t support the assumptions that we have infinite time nor infinite cognitive energy to search the full space of candidate choices to produce optimal decisions. Take for example a hiker, who has an infinite number of paths to choose from. It's irrational to assume that the hiker is capable of fully evaluating each of the infinite paths available to them to then choose the most rational/ optimal path. And yet that is the operating assumption for most modern cognitive models. To remedy this, we have the Wayfinding theory which along with an optimal-control based model can be used by researchers in private and academic settings to develop more accurate computational models of cognition in various life species

machine learningopencvhigh performance computing+15
Student: Mayank Palan
Code
Proposal

Improve the Open Event Organizer Server and implement missing features

beginner
FOSSASIA•2016Varies90h (Small)

<p>Organizing an event like a Conference or a technical festival is not an easy task. Here’s where the need for a software platform to assist the team in managing the various aspects of the event arises.</p> <p>And I believe Open-Event could be the answer to that. Open-Event Organizer server shouldn’t just be for adding/editing and accessing the sessions, speakers, tracks, etc. It should also be able to assist the organizers in planning the event, managing it, and post-event documentation.</p> <h5>Deliverables</h5> <ol> <li><strong>OAuth 2.0</strong> authentication for the API</li> <li>Proper <strong>tests</strong> for the API</li> <li>Proper <strong>documentation</strong></li> <li>API page will be loading all available endpoints automatically</li> <li>Ticketing and sales.</li> <li>Support for organizers to link their Stripe/PayPal account to receive payments when tickets are sold</li> <li>Graphical interactive scheduler for scheduling sessions into their respective rooms and timings</li> <li>Invoicing generation and emailing</li> <li>Sales statistics, Fees and tax management</li> </ol>

pythonjavascriptandroid+7
Student: Niranjan R
Code

Re-optimization using JITLink

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

In Just-In-Time compilers we often choose a low optimization level to minimize compile time and improve launch times and latencies, however some functions (which we call hot functions) are used very frequently and for these functions it is worth optimizing more heavily. In general hot functions can only be identified at runtime (different inputs will cause different functions to become hot), so the aim of the reoptimization project is to build infrastructure to (1) detect hot functions at runtime and (2) compile them a second time at a higher optimization level, hence the name "re-optimization". There are many possible approaches to both parts of this problem. E.g. hot functions could be identified by sampling, or using existing profiling infrastructure, or by implementing custom instrumentation. Reoptimization could be applied to whole functions, or outlining could be used to enable optimization of portions of functions. Re-entry into the JIT infrastructure from JIT’d code might be implemented on top of existing lazy compilation, or via a custom path. Whatever design is adopted, the goal is that the infrastructure should be generic so that it can be used by other LLVM API clients, and should support out-of-process JIT-compilation (so some of the solution will be implemented in the ORC runtime).

cllvmc+++3
Student: Sunho Kim
Code
Proposal

Italian Mars Society (IMS): Biometric Signal Sensor’s Interface

intermediate
Python Software Foundation•2017Varies175h (Medium)

<p>This project covers the development of a Tango Control’s Device Server(s) for the purpose of reading and configuring biometric signal sensors.</p> <ul> <li>Phase I of the project consists of selecting which biometrics are to be measured. Eg: Pulsioximetry, Accelerometry, etc. The next step would be to survey the commercial sensors available, and select one, or more, according to criteria like: Budget, Programming libraries available, Documentation, Signal Preprocessing capability, etc. Multi-sensor devices should be preferred over several single-sensor devices.</li> <li>Phase II consists of writing the Device Servers for the chosen devices, in Python, with abstraction and decoupling in mind. It would also entail looking into the possibility of interfacing these device servers to the existing Habitat Monitor and Health Monitor GUI.</li> <li>Phase III covers improving the signal quality and, if time allows, performing some signal analysis. This phase is slightly flexible in that if sufficient preprocessing on the signals is done by the chosen devices themselves, more work can be done on the GUI and interfacing.</li> </ul> <p>The project is part of the current studies on the simulation of an Astronaut’s Health Monitor system.</p>

pythonmercurialjavascript+3
Student: Ras-al-Ghul
Code

INTERMEDIATE exchange for IKEv2

intermediate
The Libreswan Project•2020Varies175h (Medium)

<p>Libreswan implements IPsec protocol, which uses IKEv2 for authentication and key establishment. IKEv2 uses the classical Diffie-Hellman key exchange methods which will soon become insecure and should be replaced with Quantum Computer (QC) resistant ones. Since most of QC-resistant key exchange methods require transfer of large public keys, the fragmentation of the messages is needed. Current IKE fragmentation cannot be used in the initial exchange and instead the IP fragmentation will take place. However, the use of the IP fragmentation has significant drawbacks, for instance some network devices do not allow IP fragments to pass through and hence IKE communication is blocked.</p> <p>Intermediate Exchange is a solution to transfer large amounts of data in IKEv2. A series of these exchanges may take place after the IKE_SA_INIT phase and enable message fragmentation via IKE Fragmentation mechanism. This allows the transfer of large keys without causing IP fragmentation. Implementing Intermediate Exchange for libreswan is the next important step in improving the long-term security of IKEv2 and IPsec such that the protocols will also remain secure against attacks by quantum computers.</p>

cpythonshell script+10
Student: Yulia Kuzovkova
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

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

Router Factory for Design Driven Web API Development

intermediate
Eclipse Vert.x•2017$3k–$6.6k175h (Medium)

<p>The main objective of my project is to expose functions that generate a Router from an API specification (based on an API specification standard like Swagger or RAML), to help dev teams building its services starting from a Web API specification. This method is called Design Driven Development.</p> <p>The main idea is to implement an interface inside vertx-web like this:</p> <pre><code>DesignDrivenRouterFactory routerFactory = new SwaggerDesignDrivenRouterFactory("swagger.json"); routerFactory.addHandler(HttpMethod.POST, "/product", routingContext -&gt; { // do stuffs with JsonObject routingContext.getBodyAsJson() ! }); Router router = routerFactory.router(); vertx.createHttpServer().requestHandler(router::accept).listen(8080); </code></pre> <p>This interface enables developers to create a router based on his API specification without caring about request validation and parameters parsing and other things described in API specification. Also a base interface <code>DesignDrivenRouterFactory</code> will be created to enable Vert.X framework to support multiple specifications standards</p> <p>Here is <a href="https://github.com/slinkydeveloper/twitter-wall-GSOC" target="_blank">my Twitter wall project</a></p>

javakotlinreactive extensions+2
Student: Francesco Guardiani
Code
Proposal
Showing 5665 - 5688 of 5976 Projects
235236237238239
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal