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

Improve word processor test coverage

intermediate
LibreOffice•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)

LibreOffice Writer's internal layout engine is extremely intricate and historically dense. This means that attempting to modernize and refactor it is extremely difficult without comprehensive automated tests that account for every possible case. This is precisely why this project is shifting away from conventional bug hunting and instead focusing on an analytical and metric-driven Quality Assurance approach. By utilizing gcov and lcov, it is possible to automatically determine which C++ execution branches in the core layout module (sw/source/core/layout/) are not yet tested. By reverse-engineering test documents that specifically invoke these branches, it is then possible to create comprehensive CppUnit tests that utilize parseLayoutDump() and XPath queries to mathematically validate and "lock in" the correct internal XML layout tree representation. The final deliverables will be continuous lcov coverage reports that demonstrate quantifiable metrics, custom-engineered test documents (.odt/.docx), and dozens of high-quality C++ layout tests that will be merged into sw/qa/extras/layout/. This project will create a comprehensive safety net that is significantly cheaper, easier, and safer for all core developers.

pythonandroidjava+2
Student: Manish Bera
Code
Proposal

Digital Filter Block Implementations in MyHDL and PyFDA Integration

intermediate
Free and Open Source Silicon Foundation•2018Varies175h (Medium)

<p>Design and implementation of digital filters is essential for electronics engineers. Digital filter design in hardware usually is a two stage process; algorithm development in a language like Python, Matlab or Java and RTL design in a Hardware Description Language like VHDL or Verilog. myHDL is a Python module for developing, synthesizing and testing HDL code. PyFDA is a GUI based tool in written in Python/Qt for analysing and designing discrete time filters. This project aims to leverage and demonstrate the advantages of myHDL, PyFDA and python in general in the field of Digital Filter design. Algorithm exploration, modeling, designing and simulating of digital filters can all be done in Python and PyFDA. The project will focus on development and rigorous testing of digital filter designs and their integration with PyFDA. The algorithms for each type of filter will be chosen such that the hardware utilization is kept to a minimum. Initially Systolic FIR filter and parallel path IIR filter will be implemented. Later more complicated implementations of non-linear estimation filters will be explored. The filters will be rigorously tested and integrated with PyFDA.</p>

pythonjavascriptfpga+11
Student: Sriyash Caculo
Code

Kotlin Multiplatform App Template Framework

intermediate
The Mifos Initiative•2025Varies175h (Medium)

I propose to enhance the Mifos Initiative's Kotlin Multiplatform (KMP) Multi-Module Project Generator to streamline cross-platform application development and make it more valuable for developers. My plan is to create a customizable Material Design 3 component layer for a consistent UI across platforms, implement a unified configuration system, and enhance GitHub Actions workflows for comprehensive CI/CD. I'll develop pre-built infrastructure components (networking, database, storage), streamline dependency management with Gradle plugins, improve the sync directories system, add a type-safe API client with Ktorfit, and automate library publishing to Maven Central. With my experience in Kotlin (3+ years) and Kotlin Multiplatform (2+ years), plus my extensive contributions to Mifos projects, I have the technical foundation to implement these enhancements successfully. I've created a detailed 15-week implementation plan with clear deliverables for each stage. These improvements will transform the KMP Project Generator into a more powerful and user-friendly tool, benefiting both the Mifos ecosystem and the broader KMP community by reducing development time and ensuring best practices across platforms.

mysqljavascriptandroid+5
Student: Sk Niyaj Ali
Code
Proposal

Protein sequence and structural analysis CWL pipeline for comparative biology

intermediate
Open Bioinformatics Foundation (OBF)•2020Varies175h (Medium)

<p>While there are a multitude of open source ML methods for prediction of various structural or biological related attributes, there are no open source pipelines or APIs which allow to performing a one command task for running multiple/equivalent methods and join the results in a way that facilitates comparisons and further dissemination. This limits any type of structural/comparative biology analyses, as one would need to install and run &gt;50 software and put together all the results using in-house scripts.</p> <p>This project aims at developing a scalable workflow that receives the protein FASTA file and runs a series of structural and phenotype related predictors, generating a knowledge dataset that will facilitate further exploration and comparisons according to the following categories of features: secondary structure, solvent accessibility, disordered regions, PTS modifications or binding sites.</p> <p>Deliverables of this project consists of 8 modules for each analysis type organised as Docker images, a Python library for processing inputs &amp; outputs of the included methods and a CWL pipeline that will facilitate a one-line command run of all the predictors (default or custom configuration).</p>

pythonjavascriptc/c+++3
Student: Eliza Martin
Code

GeoModelExplorer: improving interactive 3D geometry visualization tool based on Qt3D

intermediate
CERN-HSF•2020Varies175h (Medium)

<p>Interactive visualization can provide intuitive insights for experiment setups and results in many domains, including High Energy Physics. Therefore, Virtual Point1 (VP1) was developed by ATLAS for 3D event display. Nevertheless, it seems a pity that it is based on an old graphics engine(OpenInventor) and resides in a big project(full ATLAS experiment software stack) with many dependencies.</p> <p>To get free of these limitations, GeoModelExplorer, a super-lighter version of VP1 has been developed, with a strong focus on the visualization of geometry data. Some of the important next steps are to replace the old 3D engine, improve existing functions and add more features. All of them are waiting for development.</p> <p>In this project, I will take these steps one by one, integrate the modern graphics engine Qt3D, improve the geometry rendering effects, extend the mesh I/O abilities, and add smooth animation for view inspections. There will be a large amount of design and engineering work but I will take extreme care. This project will eventually make contributions as part of the current software modernization effort in ATLAS.</p>

pythonc/c++machine learning+6
Student: Huajian Qiu
Code

Bookmarks Tree View-GSOC

intermediate
Chromium•2024$3k–$6.6k175h (Medium)

The goal of this project is to reintroduce a tree view functionality into Chrome's bookmarks side panel, addressing user feedback and enhancing usability. The current flat list view lacks the ability to view all bookmarks at once, leading to user dissatisfaction. To solve this, we will transform the compact view into a tree view while retaining all new features introduced in the recent UI overhaul. This will involve retaining drag-and-drop functionality for bookmark organization within the tree view, ensuring compatibility with screen readers, and conducting comprehensive testing for usability and accessibility. Key Deliverables: 1. Implement tree view functionality in the bookmarks side panel, allowing users to view all bookmarks at once. 2. Update existing drag and drop functionality for organizing bookmarks within the tree view. 3. Ensure accessibility standards are met, focusing on tab traversal and screen reader support. 4. Conduct thorough testing to ensure the usability, accessibility, and functionality of the tree view. 5. Prepare comprehensive documentation detailing the implementation, usage, and features of the new tree view in Chrome's bookmarks side panel.

pythonjavascriptjava+2
Student: Paras Awasthi
Code
Proposal

Open Event

intermediate
FOSSASIA•2018Varies175h (Medium)

<p>The <strong>Open Event</strong> Project offers event managers a platform to organize all kinds of events including concerts, conferences, summits and regular meetups. The various components support organizers in all stages from event planning to publishing, marketing and ticket sales. Automated web and mobile apps help attendees to get information easily.</p> <p>There are two major divisions of this project:</p> <ol> <li>Implementation of numerous features on the <strong>Open Event Server</strong> in order to make it feature complete. Some of the features that we aimed for were integration of <em>payment system</em>, <em>tickets</em>, <em>taxes</em>, <em>promo codes</em> etc. </li> <li>Integration of missing endpoints and related features on the <strong>Open Event Frontend</strong> and <strong>Open Event Orga</strong> app. Some of the features that we aimed for in the <em>frontend</em> were the implementation of <em>promo codes</em>, <em>notifications</em> while <em>tracks</em> and <em>speakers</em> endpoints were targeted for the orga app.</li> </ol>

pythonjavascriptandroid+7
Student: Saurav Tiwary
Code
Proposal

Mesa-Frames: Stats & Event-Driven Data Collection with Streamed Storage

advanced
Project Mesa•2025Varies350h (Large)

This project aims to significantly enhance Mesa-Frames by building efficient and scalable data collection tools for large-scale agent-based simulations. The core focus is on developing a flexible framework that allows researchers to analyze simulation data with greater precision and lower overhead. One of the main components, the Stats Collection, will enable users to define exactly which statistics they want to track—such as mean, max, or count—helping reduce both memory usage and computation time. Another key feature is the Event Driven Collection, which records data only when predefined conditions are met. This ensures researchers capture meaningful insights while avoiding unnecessary logging and storage. To support even larger simulations, the project will also include integration with external storage systems like PostgreSQL and S3, allowing collected data to be streamed directly to disk or the cloud. In addition to these core improvements, the project will focus on performance optimization through lazy execution with Polars and better vectorization. Clear, modular documentation and a focus on usability will ensure Mesa-Frames remains an accessible and powerful tool.

pythonui/uxLLMs+4
Student: Ben Geo Abraham
Code

Building Rich User Interfaces for Airavata Services

advanced
Apache Software Foundation•2024Varies350h (Large)

Currently, Apache Airavata Managed File Transfers (MFT) is accessed through a command line interface (CLI), using commands such as mft storage list. However, it is also possible to access MFT through the gRPC API. Thus, developing a desktop application for a user interface is entirely possible and would make MFT accessible to even more people. Such a user interface would have the following functionalities and deliverables: - Provide all the functionalities the MFT CLI provides, such as: - Start & stop a MFT instance - Storage Functionality - Register storages (S3, Google Cloud Storage, Azure, Openstack SWIFT, SCP, FTP, Box, - DropBox, OData, Agent, HTTP) - List storages - Remove storages - File Functionality - List files in storage - Move files between storage endpoints - Add files to storage - Remove file from storage - Upload files to storage - Search for data files between multiple storage endpoints - Get performance numbers (such as transfer rates in each agent) and other analytics Such a user interface will likely involve the use of ElectronJS on the frontend and a node.js backend, which connects through the gRPC API to communicate with Airavata MFT.

pythonjavascriptjava+7
Student: Ganning Xu
Code

Project 12: Empowering Kubeflow Documentation with LLMs

intermediate
Kubeflow•2025$3k–$6.6k175h (Medium)

refer notion site for better view : https://smart-rhubarb-c5c.notion.site/GSoC-2025-Proposal-Project-12-Empowering-Kubeflow-Documentation-with-LLMs-1c209ac9a7bd80e6941ee51ab6601c7c This project aims to build an AI-powered assistant for the Kubeflow ecosystem using Retrieval-Augmented Generation (RAG) and a long-context LLM. The assistant will index Kubeflow Github repository including, GitHub issues, and community discussions using a structured pipeline involving Feast (feature store) and Milvus (vector DB). It will support real-time queries through a FastAPI WebSocket interface and serve responses via KServe. Key deliverables include: End-to-end RAG pipeline integrated with Kubeflow Pipelines & Feast GitHub-triggered document ingestion and vector index updates LLM deployment and retrieval API with RBAC controls Evaluation loop using “LLM-as-a-Judge” Monitoring setup with Prometheus + Grafana Frontend integration with Hugo-based docs site This project will improve Kubeflow’s developer experience by enabling contextual, cited answers directly from its ecosystem.

pythontensorflowkubernetes+5
Student: Santhosh Toorpu
Code
Proposal

implement pg_thrift plugin for postgreSQL

advanced
PostgreSQL•2018Varies350h (Large)

<p>One of advantages of document-oriented databases like MongoDB or Couchbase over RDBMSs is an ability to change the data scheme easily, fast and often. The traditional approach in RDBMS world involves doing an expensive ALTER TABLE operation, slow upgrade of an existing data, and stuff like this. This approach is often slow and inconvenient for application developers. To solve this issue PostgreSQL provides JSON and JSONB datatypes. Unfortunately JSONB has a disadvantage of storing all documents keys, which is a lot of redundant data. One possibility to to reduce JSONB redundancy is to use zson extension. It compresses JSONB documents using shared dictionary of common strings that appear in all or most documents. This approach has its limitations though. Particularly, since data schema evolves, the dictionary has to be updated from time to time. Also zson can affect the build-in mechanism of PostgreSQL of compressing data using PGLZ algorithm since this mechanism uses some heuristics to recognize data that compresses well. Thus sometimes zson can reduce the overall performance. The idea of this project is to create an extension that provides Thrift support which solves zson problem.</p>

cpostgresqlperl+8
Student: Yan Cui
Code
Proposal

OpenRISC Linux Feature Development

advanced
Free and Open Source Silicon Foundation•2025Varies350h (Large)

​​Jump Label Implementation​​ aims to eliminate branch overhead in kernel code by dynamically patching JMP/NOP instructions at runtime using GCC's asm goto feature. This involves defining static branch templates (ARCH_STATIC_BRANCH_ASM for NOP cases and ARCH_STATIC_BRANCH_JUMP_ASM for JMP cases) and implementing core functions (arch_static_branch and arch_static_branch_jump) along with a runtime patching mechanism (arch_jump_label_transform). The key deliverable is near-zero-cost branch decisions, significantly improving performance for frequently checked kernel conditions like tracepoints and debugging checks. ​​Ftrace Implementation​​ provides efficient function tracing (function) and call-graph profiling (function_graph) with minimal overhead. The -pg compiler flag inserts mcount() calls that dynamically redirect to either a no-op stub (when disabled) or a full tracer (when enabled). The implementation includes dynamic redirection in mcount(), the core function tracer (ftrace_trace_function), and the extended function_graph tracer with entry/exit hooks (ftrace_graph_caller and return_to_handler). This enables deep call-stack analysis while maintaining low runtime cost when tracing is inactive, supporting dynamic kernel debugging with minimal performance impact.

pythonjavascriptfpga+11
Student: Chen Miao
Code

SimNIBS TMS Electric Field Simulation and Head Modeling Integration in InVesalius

intermediate
Invesalius•2026Varies175h (Medium)

Implementation of a direct integration between SimNIBS and InVesalius to enable subject-specific head model generation and TMS electric field (E-field) simulations within InVesalius. Currently, head modeling and E-field simulations require external workflows and manual data handling. This project will integrate the full pipeline into InVesalius, allowing users to generate MRI-based head models, position and orient TMS coils using existing neuronavigation tools, configure simulation parameters, execute simulations internally, and visualize E-field magnitude (|E|) directly on 3D anatomical models. The activity will focus on implementing a Python-based interface to SimNIBS, aligning coordinate systems, handling simulation inputs/outputs robustly, and integrating results into the InVesalius visualization environment. Deliverables: Integrated MRI-based head modeling pipeline. Python interface module connecting InVesalius to SimNIBS. UI panel for head modeling and simulation configuration. Execution of TMS E-field simulations within InVesalius. 3D visualization of E-field magnitude (|E|). Technical documentation.

pythoncythonnumpy+2
Student: Yiqi
Code

Rucio WebUI Revamp

intermediate
CERN-HSF•2022Varies175h (Medium)

Rucio has proven its potential to be used for providing functionality to scientific collaborations to organize, manage, monitor, and access their distributed data and dataflows across heterogeneous infrastructures. What it needs is a revamped user-friendly UI. This will not only encourage existing users to get a feel of how Rucio continues to grow and reach new milestones, but also increase the adoption of the Rucio WebUI in general. The desired outcomes of my stint would not only involve a complete revamp of the existing UI by building a UI library of our own but also presenting users with a new & intuitive dashboard, keeping the core functionality of Rucio in mind. Rucio also supports multiple types of users and their specific workflows. The first task would involve migrating the WEBUI to a pure REST’ful architecture would require identifying and implementing new REST endpoints on the Rucio Server and developing a dynamic cross-platform ReactJS application capable of consuming the REST API directly. The second task is to improve the overall user experience for different ‌users. The new dashboard would allow users to get a quick overview of relevant activity and provide quick access to frequently used functionalities.

pythonc/c++machine learning+6
Student: Nimish B
Code
Proposal

Port fortran-lang.org to Sphinx

beginner
Fortran-lang•2022Varies90h (Small)

The idea is to Port the Entire site from Jekyll to Sphinx and MyST parser to add internationalisation as it comes built in Sphinx which also acts as an added advantage in implementing the site using sphinx and to increase the ease of maintenance and to make it easier for future contributors to contribute to the organisation.My Solution proposes the following Implementations: 1.Implement Interactive Community page using Js 2.Use Markdown for generating the static site in Sphinx + Myst 3.Internationalization Using Sphinx 4.Ease of Portability of Learn section of Fortan-lang.org site 5.Implement a new Sphinx extension to Create Docutil nodes in python. 6.Automate The Build of translated site using GitHub pages and Add Documentation to the New Fortran-lang.org site. 7.Addition of Extensive Documentation in Markdown files to the new Sphinx site and to make it easy for the new members to contribute to the community. 8.Implement changes and enhancements in UI/UX. 9.Implementation of landing page of site and Various pages and Layouts of the Site from Jekyll to Sphinx Using Markdown (Myst Dialect).

pythonc/c++llvm+3
Student: Henil Shalin Panchal
Code
Proposal

Flexible GovDoc Scanner - Eftihis Drakakis

beginner
Open Technologies Alliance - GFOSS•2025Varies90h (Small)

Greece’s public business records, available through the GEMI portal, contain valuable information such as company names, founding dates, and key individuals, but much of it is locked away in difficult-to-search PDFs. To make this data more accessible, we’re building an open-source tool that transforms these documents into a searchable, user-friendly database—legally and ethically. Instead of scraping, we will systematically fetch records from Greece’s official Open Data Portal, extract metadata and text using OCR and NLP tools , and organize everything in OpenSearch, which efficiently handles Greek text. A simple REST API will allow users to query companies, dates, and individuals while ensuring scalability, smart search, pagination, and overload protection. The project will provide an automated pipeline for downloading, processing, and indexing documents, along with clear documentation, Docker support, and easy cloud deployment. By unlocking these records, we’re not just solving a technical problem—we’re making public data truly public, empowering watchdogs, entrepreneurs, and citizens to better understand Greece’s business landscape.

pythonmysqljava+7
Student: Eftihis D
Code

Extending the Grafana Integration of Performance Co-Pilot

advanced
Performance Co-Pilot•2020Varies350h (Large)

<p>Goal of this project is to improve and build upon existing Grafana intergration for Performance Co-Pilot.</p> <ul> <li>Developing a <strong>reactive dashboard</strong> and using PCP metrics</li> <li>Implementing support for PCP <strong>derived metrics</strong> in the Vector data source, as described in the PCP REST API documentation</li> <li>Improving the <strong>metric search</strong> process by creating a new page for live, full-text search on PCP metric names, instances, instance domains and their descriptions, if any</li> </ul> <p>Based on performance metrics from PCP and a predefined rule set, the <strong>reactive dashboard</strong> should display only relevant metrics to the user. For example, if the CPU utilization is high, it should show an overview of CPU statistics and processes contributing load. The user should then be able to drill down into more specific areas of interest - e.g. present graphs about lock contention. For each recognized performance issue a link should be presented to the user on how to resolve the issue. In this way the dashboards guide users toward possible root cause of performance problems.</p>

javascriptjavaruby+12
Student: Miroslav Foltýn
Code

Gnuastro Library in Python

beginner
OpenAstronomy•2022Varies90h (Small)

Gnuastro is primarily written in C because astronomical datasets are large and thus need to be efficient with few dependencies. Therefore, its most commonly used interface are Gnuastro’s command-line programs. However, Gnuastro’s also has an extensive set of installed, dynamic C/C++ libraries, which are the actually beating heart of the programs. On the other hand, many projects today are done in Python, almost excuslively using Numpy for their numerical operations (like data arrays). Python and Numpy are actually written in C, therefore they have very well-defined interfaces for communicating with installed C libraries, using CPython. Since both Gnuastro and Numpy's core data structure are very similar, we plan on building a converter between the two. This will make it possible to perform all data operations using Numpys C-API. This will be followed by adding a low-level wrapper infra-structure which will allow easy usage of Gnuastro’s powerful libraries in Python. Thus, the final goal is to have Gnuastro be an importable module in Python (just like Numpy) and have all the inner data operations of Gnuastro be performed using Numpy's C-API.

cpythonjulia+7
Student: Jash Shah
Code
Proposal

Improve Accessibility

intermediate
Oppia Foundation•2023Varies175h (Medium)

With this proposal, my aim is to make Oppia's learner-facing pages more accessible by by learners having any form of disability. My suggested method involves two-fold approach. I'll start by addressing the accessibility issues (a11y) that have already been reported on the site. This will entail addressing difficulties with heading-related issues, focus management, colour contrast, and more. Many of these a11y issues have contributors associated to them. While I resolve the unassigned problems, I will be available to help any contributors who get stuck or require further support. Second, I'll utilise Lighthouse to evaluate every Oppia page that is intended for students, raising their accessibility scores to a perfect 100. Each learner-facing page's Lighthouse test audits will need to be examined in order to make the necessary changes. This will include adding alternative text for images, making sure header tags have the right semantic structure, and making sure aria-roles are contained by the appropriate parent. Also, in order to aid contributors in understanding the Lighthouse audit procedure and troubleshooting any potential problems that may emerge throughout testing, I will be adding guidance on how to debug Lighthouse tests to the Oppia documentation.

pythonjavascriptangularjs+10
Student: Patel Muhammad
Code
Proposal

Improvements to KDE Web Infrastructure

advanced
KDE Community•2020Varies350h (Large)

<p>KDE has a vast web infrastructure. Some KDE websites have not been upgraded in a long time and use dated technologies.</p> <p>The first part of this project involves porting KDE's main website <a href="https://kde.org" target="_blank">kde.org</a> to Hugo - A Go based static site generator. This would allow for ease of development, faster load times and more security.</p> <p>KDE websites also currently use OpenLDAP and a PHP application to authenticate and manage users (<a href="https://identity.kde.org" target="_blank">identity.kde.org</a>). OpenLDAP is an old and complex method of authenticating and managing user identity and several modern approaches are available. Moreover many services do not support OpenLDAP authentication (Eg. discourse). One of the newer approaches is to use OAuth2. OAuth2 is a modern approach to authentication and fixes the various issues with LDAP. So, the project also involves migrating <a href="https://season.kde.org" target="_blank">season.kde.org</a> to OAuth and giving it a much needed visual overhaul at the same time.</p>

c/c++qtqml+6
Student: Anuj Bansal
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

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

Playlists Sorting and Organization

intermediate
MetaBrainz Foundation Inc•2026Varies175h (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
Showing 5641 - 5664 of 5976 Projects
234235236237238
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal