Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
4718 Projects Found
Sort by

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

advanced
Apache Software Foundation•2018Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
350h (Large)

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

pythonjavascriptjava+7
Student: Tzu-Chiao Yeh
Code
Proposal

AVX2-Accelerated Collision Detection for Real-Time MPC in Humanoid Robotics

advanced
OpenVINO Toolkit•2026Varies350h (Large)

This project aims to resolve the computational bottleneck in self-collision detection within the OCS2 framework for humanoid robotics. The current implementation in ocs2_self_collision operates on a pair-by-pair basis, iterating through collision pairs and calling PinocchioGeometryInterface::computeDistances() followed by Jacobian and penalty term calculations. This sequential approach is not SIMD-friendly by default and fails to utilize the parallel processing power of modern CPUs. To address this, I propose replacing the current computeDistances()-based distance computation with a high-performance implementation inspired by SIMD-amenable structures. A primary focus will be exploring / integrating SIMD-friendly data structures, such as Collision-Affording Point Trees (CAPT), to represent the storage and computation of collisions. This transition aims to transform the collision pipeline into a vectorized workflow that can be efficiently accelerated using AVX2 intrinsics. The primary deliverables include the clean integration of this accelerated engine into the ocs2_self_collision pipeline, accompanied by rigorous correctness checks against Pinocchio/FCL baselines. Furthermore, I will provide a comprehensive end-to-end latency evaluation using ocs2_mobile_manipulator to demonstrate the reduction in average and maximum compute cycle times. This work will significantly enhance the real-time performance of MPC-based humanoid control in complex environments.

pythonc++x86+1
Student: asterich
Code

Exploring optimization strategies for RoboticsBackend container

advanced
JdeRobot•2026Varies350h (Large)

The JdeRobot Robotics Academy utilizes massive monolithic Docker images, which result in critical download issues for students, and demands insecure root daemon privileges to execute containers. To address this, I plan to design a highly optimized multi-stage build framework for RoboticsBackend, which will minimize total megabytes for download by students and reduce image size using strict apt layer squashing and source-level pruning of heavy ROS2 meta-packages like Aerostack2 and OMPL. Moreover, I will transform the execution framework to a secure, daemonless Podman-based container execution system, which will enable precise namespace mapping using –userns=keep-id and native display socket passthrough for safe execution of GUI-based Gazebo simulations without compromising host security. Deliverables : 1. Optimized Container: A new, optimized image with a mathematically provable reduction in total megabytes for download and build layers. 2. Rootless Execution: A fully functional Podman-based environment for secure execution of the entire database and frontend stack without a Docker daemon. 3. Developer Documentation: New official documentation on new multi-stage build paradigms and executing containers rootlessly.

pythonrosgazebo+2
Student: Kartik Jangid
Code
Proposal

Improving Zulip Bots and Integrations.

intermediate
Zulip•2021Varies175h (Medium)

<p>Zulip provides powerful utility for bots and integrations, but parts of the system (like embedded bots) are still work in progress. To encourage more users to use the bots and integrations, and to also foster a better development experience with bots and integrations, this project aims at implementing better UI for the users to browse through available bots with verbose description, provide more developer-friendly interfaces for creating bots, and other related tasks to improve the bots system.</p> <h4>Improve the UI to Encourage Bot Usage</h4> <p>Display a list of available bots for all users and show accompanying descriptions or help messages. This sub-goal will be aiming at improving the UI to show more information about the bot.</p> <h4>Encourage Error Handling for Bots</h4> <p>Propose a way to raise custom errors from the API layer instead of leaving the error message from the server as is (e.g. {“result”: “error”, “msg”: “foobar”}) and requiring the developers to parse the error message to handle cases of error.</p> <h4>Create Standard for Bots Handling Commands</h4> <p>Support standard commands while keeping our layer of bot as thin as possible and allow standardized metadata to describe the behavior of our bots.</p>

pythonjavascriptdjango+5
Student: Zixuan Li
Code
Proposal

Project Proposal Geant4-FastSim - ML pipeline optimization using Kubeflow

advanced
CERN-HSF•2022Varies350h (Large)

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

pythonc/c++machine learning+6
Student: Guneet Singh Kohli
Code

Open Civic Data Admin Tools

advanced
Open States•2017Varies350h (Large)

<ol> <li><p>The new admin tools will identify the data quality issues in the database and allow Open States admins to know about the current status of quality of scrapers and to manually fix or modify the data quality issues or mark them as exceptions. These tools will also provide admin the right to consider the requests posted by the users to report any wrong or missing information on openstates.org. This will supports Open Civic Data Backend with important features like,</p> <ul> <li>Common Status Page for all states containing current status of different parameters</li> <li>Sub pages for status of specific sessions/states etc.</li> <li>Name Resolution Tool</li> <li>Merge Tool</li> <li>User Feedback Tool</li> <li>Data Quality Issues &amp; Exceptions Tool</li> <li>Retirement Tool</li> <li>Advanced filters to sort data accordingly</li> <li>Fast search queries using Django-ORM</li> </ul> </li> <li><p>Pupa Conversion of Scrapers from Billy and Fixing bugs &amp; updating scrapers for different states.</p> </li> </ol>

pythonpostgresqljavascript+3
Student: Hitesh Garg
Code
Proposal

Verilator VPI array value accessor Mentorship Project

Intermediate
•Varies175h (Medium)

Verilator, an open-source Verilog emulator, is a well-established and community-supported hardware verification tool. It is widely used in developing and testing RISC-V CPU RTL designs. Rocket, CVA6, BOOM, and most other RISC-V RTL designs in the RISC-V Chipyard toolkit lean on Verilator to emulate their respective designs. A common requirement in hardware verification is the ability to access the value of hardware elements and registers during live emulation. The Verilog Procedural Interface (VPI) is an interface that enables this ability. It is defined under the IEEE 1364 and IEEE 1800 standards. Two of the functions provided by VPI are “vpi_get_value” and “vpi_put_value”, these are the sole function that allows C/C++ code to access Verilog scalars during live emulation. Currently, accessing elements within an array requires the use of iterators and consecutive calls to these functions. This poses a high-performance cost when attempting to validate the contents of large arrays. However, IEEE VPI standard does define “vpi_get_value_array” and “vpi_put_value_array” functions, which allow C/C++ code to access verilog arrys with a single call. These functions are unimplemented in the latest version of Verilator and depending on their implementation, may be used to access arrays with less memory utilization, fewer instructions, and faster emulation time.

TBA
Proposal

CAPA: Ghidra Integration

intermediate
FLARE•2023Varies175h (Medium)

CAPA is the FLARE team’s open-source tool to identify program capabilities using an extensible rule set. Each rule is matched against features that CAPA extracts from a program. Extracted features include file-level features such as strings, section names, imports, and exports and function-level features such as API calls, string and byte references, instruction mnemonics, and number constants. CAPA uses feature extractors, called "backends", to extract features from supported file types (PE, ELF, and .NET) and architectures (32- and 64-bit x86). Each backend is built around an existing tool or library that provides file parsing and disassembly capabilities. CAPA uses this to extract features. CAPA currently implements backends using Vivisect, IDA Pro, and dnfile. Ghidra is a popular open-source disassembly framework with a robust API to access its analysis. Programs can interact with a wealth of information that includes parsed file formats and disassembled code. The goal of this project is to develop a Ghidra backend for CAPA using Python 3 (via Ghidrathon) and Ghidra’s scripting API. Users should be able to invoke CAPA such that it uses Ghidra’s analysis engine and/or invoke CAPA from within Ghidra.

pythonida-proGhidra+1
Student: Colton G
Code
Proposal

From Messy Subjects to First-Class Genre Tags

intermediate
Internet Archive•2026$3k–$6.6k175h (Medium)

Open Library has millions of book records tagged with inconsistent, unstructured subject strings, for example, "science fiction", "Science Fiction", and "sci-fi" are treated as completely different tags, causing patrons to miss thousands of relevant books depending on how they search. This project solves that by building system-wide support for first-class genre tags on Works, directly addressing issue #11610. The solution works in four connected layers: first, developing a controlled genre vocabulary and a mapping dictionary from messy subject strings to canonical genre labels; second, updating the work schema in infogami to add a genres field storing canonical strings that serve as keys to fetch corresponding Tag objects; third, building a batch backfill pipeline that processes tens of thousands of high-demand works and populates their genres field; and fourth, updating Solr to index and facet by genre, displaying genre chips on book pages, and adding a librarian editing UI with autocomplete. By the end of GSoC, a patron searching for science fiction will get consistent, accurate results regardless of how they type it because works will have clean genre tags, indexed by Solr, backed by canonical Tag objects, and maintainable by librarians.

pythonjavascriptpthon+6
Student: Chisom Nnamani
Code
Proposal

Automating Force Based Layout Scaling And Network Visualization For Media Source Networks From MediaCloud Topic Graphs

intermediate
Berkman Klein Center for Internet & Society at Harvard University•2018Varies175h (Medium)

<p>Media source networks generated from Mediacloud topic graphs are currently visualized using software like Gephi with Force based layouts, however scaling the graph by expanding and contraction to reveal the network structure takes trial and error and domain expertise. Since python libraries like networkx don't have extensive support for network visualizations like Gephi, visualizing high dimensional networks become very hard. Multiple issues like node overlaps, label overlap , lack of utility functions, having a bad layout complicate the task of coming to a good network visualization.</p> <p>To solve it we implement <a href="https://github.com/Tahsin-Mayeesha/Mediaviz" target="_blank">Mediaviz</a>, a network visualization library which has been deployed as a package into pip. It provides functionalities for force based layout such as force atlas 2, automatic scaling to prevent node overlap, Gephi like features for network filtering, coloring, node resizing, prevention of label overlap and community visualization. Mediaviz uses force atlas 2 layout as default and scales the layout automatically for graphs with 100-1000 nodes that has a power law linking structure, but it can also be used with other layout algorithms.</p>

javascriptruby on railselasticsearch+2
Student: Tasmiah Tahsin Mayeesha
Code

istSOS Role-Based Web Administration

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

This project adds proper role-based access control to istSOS4 by making the web administration interface reflect the permissions already enforced in PostgreSQL through Row-Level Security (RLS). Right now, the backend enforces access correctly, but the UI does not — every user sees the same controls. This project fixes that. Each role (administrator, editor, viewer, sensor) will only see the pages and actions they are allowed to use. It also simplifies user and policy management by removing the current two-step workflow. Creating or updating a user will automatically apply the appropriate policies, reducing configuration mistakes and making the system easier to operate. To support real deployments, the project adds basic observability and debugging tools. A permission matrix shows what each role can do, and audit logs record access-related events. In addition, small utilities like permission explanation, access simulation, and change impact preview help admins understand and verify changes before applying them. The project also explores integration with external authentication providers (OIDC) so istSOS4 can work with single sign-on setups, including Grafana, without changing how permissions are enforced. Overall, the focus is to make permissions visible, predictable, and manageable for administrators.

pythonjavascriptc/c+++4
Student: Kinshuk Sanand
Code
Proposal

Traffic Intersection Monitoring System with OpenVINO

advanced
OpenVINO Toolkit•2025Varies350h (Large)

This project develops an AI-powered desktop application for real-time traffic monitoring and intelligent automation. It detects vehicles, pedestrians, and traffic violations (e.g., Red-Light jumping, Improper Stopping Over Crosswalk at RedPedestrian Right of way Violation Detection) across multiple intersections, providing actionable insights for smart city traffic management. The system leverages YOLOv11 for object detection, trained on a combination of synthetic and real-world traffic data. Synthetic scenes are generated using CARLA, ensuring robustness under diverse and challenging traffic conditions. Detection models are optimized with OpenVINO for deployment on edge devices such as CPUs, integrated GPUs. A desktop dashboard built with PySide6 (Qt6) provides live video feeds with detection overlays, multi-camera support, and performance metrics. Multi-object tracking is implemented using ByteTrack for persistent identification of vehicles and pedestrians. To enhance scene understanding, Vision-Language Models such as Mistral is integrated, generating concise textual summaries of traffic patterns and contextual information for detected violations. Real-time analytics, IoT integration with MQTT, and visualization via InfluxDB and Grafana enable actionable insights for urban planning and automated law enforcement.

pythonc++x86+1
Student: Jatin Sachdeva
Code
Proposal

Improved Fortran Interface Generation for PETSc

advanced
Fortran-lang•2025Varies350h (Large)

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

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

OCSMesh Parallelization

advanced
IOOS•2025Varies350h (Large)

OCSMesh is a Python package designed for generating unstructured meshes tailored to ocean modeling. However, its current workflow, particularly the Digital Elevation Model (DEM) processing and JIGSAW mesh generation steps, remains highly time-consuming and not well-optimized for High Performance Computing (HPC) environments. To address this bottleneck, I propose introducing parallelism into the most computationally intensive stages of the workflow: DEM processing and JIGSAW-based meshing. My approach involves leveraging parallel computing libraries such as Dask and mpi4py to scale these operations across multiple cores and nodes. For the preprocessing stage, several components are already optimized for single-node performance and can be extended to work efficiently in an HPC setting. Regarding JIGSAW meshing, I plan to implement a domain decomposition strategy, partitioning the domain into smaller subdomains that can be meshed independently in parallel. These subdomain meshes will then be seamlessly merged to form the final unified mesh. This parallelized workflow is expected to dramatically reduce mesh generation time, enabling more scalable and efficient processing for large-scale ocean modeling tasks. I aim to integrate mpi4py support into the key functions across the codebase, while using Dask specifically for raster windowing and DEM data handling.

pythonocean sciencejava+3
Student: Yashveer_Singh
Code
Proposal

Graphical interoperability between CyberEther and GNU Radio (OOT module).

advanced
GNU Radio•2026Varies350h (Large)

This project aims to create OOT module, that uses CyberEther's GPU-accelerated framework which uses low-level graphics APIs to create high-performance sinks to visualize GNU Radio data streams in a normal GRC workflow. current implementations of these sinks rely on `gr-qtgui` which is fine but it would be a better to have the option of choosing CyberEther sinks which would be more optimized for maximum throughput and low latency along with a modern design. Main challenges are: minimizing data movement from the GR scheduler to CyberEther tensors, as in high sampling rates unnecessary copying would be expensive and undermine whole native performance edge. Also, CyberEther's current public plotting path internally manages a shared runtime built around `Jetstream::Instance`, and a normal GNU Radio flowgraph can have multiple sinks which would be tricky to manage safely. My core implementation target is a robust first sink family around lineplot and waterfall, with spectrogram support in the second half of the project if the lower-level CyberEther path is needed. These challenges(and other) can be resolved by architecting new solutions which borrow from past implementations namely `gr-cuda` for custom buffers, `gr-cyber` (an earlier prototype from Luigi, the creator of CyberEther) and `gr-fosphor` for relevant challenges.

pythonc++dsp+6
Student: itsYoussef
Code

Hyperledger - Runtime-checked automated programming for chaincode development Mentorship Project

Intermediate
•Varies175h (Medium)

Can we make ChatGPT write chaincode for us? Automated programming for other blockchain platforms is an already emerging topic, but Fabric has not been really addressed yet. This is an experimental mentorship with equal weight in research and hands-on coding, with the following goals. - To review existing examples and approaches of automated programming for smart contracts of other platforms (i.e., Solidity). - To explore the technically feasible options of automated chaincode programming for Hyperledger Fabric (incl. ChatGPT) and select one for further work. - To formulate a chaincode specification style which “seems to work well enough” on a set of representative examples with automated programming. (We don’t know yet what will work; One-shot or iterative? Requirement set or Behavior-Driven Development (BDD)? Conversational or formal specification? And so on.) - To create support for translating the specification partially or fully to runtime verification code, which can wrap the chaincode implementation. On the last point: starting from a specification is a tried and tested way to create verifier code either manually or automatically and is much easier to do correctly than creating the implementation correctly from a specification. We plan to keep this last point “classic”: i.e., no ChatGPT here. Specification-based verification criteria are usually amenable to development time verification, too (with static analysis, model checking, etc.).

TBA
Proposal

Improve user experience using the Jupyter toolkit

intermediate
NumFOCUS•2024Varies175h (Medium)

The UI Toolkit serves as a component library tailored for crafting web interfaces within the Jupyter ecosystem, encompassing platforms such as Jupyter Hub, Jupyter Widgets, and Jupyter Lab. With the introduction of this toolkit, the aim is to capitalise on its capabilities to enhance UI consistency and alleviate maintenance overhead. Here's a structured plan to achieve this: 1.Use toolkit search/input for all search/inputs: filebrowser, extension manager, debugger kernel source 2.Use toolkit button for all buttons: Dialog, extension manager, notification, running tabs 3.Use toolkit tree view for all tree view: table of content, debugger variables and running tabs 4.Use toolkit for the settings editor 5.Add icon component to the toolkit 6.Use toolkit icon for LabIcon 7.Add window split component to the toolkit 8.Add tree grid component to the toolkit 9.Add dock panel to the toolkit 10.Explore switching default renderer in lumino by the toolkit: a.Menu b.Tab panel c.Dock Panel I am committed to collaborating closely with my mentor, @Frédéric Collonval, to tackle these challenges efficiently and deliver tangible results within the stipulated timeframe of the Google Summer of Code program.

pythonjavascriptr+3
Student: Mehak Jain
Code
Proposal

Scaladoc search in Protosearch

intermediate
Scala Center•2024Varies175h (Medium)

The problem I aim to solve is the inefficiency in searching for specific Scala code information, particularly within Scaladoc documentation. Currently, developers often face challenges navigating external websites or manually sifting through code. To address this issue, I propose to integrate Scaladoc search functionality into Protosearch, a documentation search tool. By leveraging existing data structures and indexing/querying mechanisms in Protosearch, I plan to develop a Scaladoc Parsing Module to extract relevant metadata from Scaladoc comments and an Indexing Module to organize and store Scaladoc content for efficient search operations. The deliverables of this project include: 1. Scala Doc Parsing Module: Develop a module to access Scaladoc data in a structured way using tools like Scalameta 2. Scala Doc Indexing Module: Create a module to process and index Scaladoc content into Protosearch's existing data structures 3. User Interface Enhancements: Design and implement user interface enhancements within Protosearch to support Scaladoc search functionality, ensuring a seamless and intuitive search experience for developers. 4. Comprehensive Documentation: Document the implementation details, usage, and maintenance of the Scaladoc search feature, providing clear instructions for developers on how to utilize the functionality within Protosearch.

#scala#scala_lang#jvm+7
Student: A S
Code
Proposal

Update DBpedia Sparql for newly updated wiki resources and specifically related to pandemic, healthcare, and heath AI fields

intermediate
DBpedia•2021Varies175h (Medium)

<p>IMPACT User-friendly QA platform for a given DBpedia resource and specifically about pandemic in real-time.</p> <p>GOALS To improve the DBpedia Sparql for real-time monitoring of pandemic situations near the users and the interested country by the users. Compile pandemic data and wikidata for answering users' questions by query databases, and support research and development in the healthcare field related to model predictions and vaccine development.</p> <p>DESCRIPTION As Google engine can answer any question, DBpedia Sparql can query databases and answer questions using Wikipedia resources. The COVID-19 pandemic is an ongoing global pandemic, and humans would need to co-exist with the viruses. We should compile the public wikidata related to coronavirus and learn from them. The aim of this project is to update DBpedia Sparql tool for answering questions related to wikidata and specifically about the coronaviruses. Thus, the improved DBpedia Sparql tool would provide better understanding of the coronavirus pandemic for the public, and serve as a platform for research and development in the public healthcare field.</p> <p>WARM-UP Git repo: <a href="https://github.com/guang-zh/coronavirus_info_app.git" target="_blank">https://github.com/guang-zh/coronavirus_info_app.git</a></p>

javascalardf+7
Student: Guang Zhang
Code

GTK4 Transition Part 2: Sugar Shell

intermediate
Sugar Labs•2026Varies175h (Medium)

The Sugar Shell is the core desktop environment of Sugar and is responsible for activity launching, the Journal, the Frame, and system integration through DBus. The current Sugar Shell is built on GTK3, and several core components still depend on deprecated GTK3 APIs, which must be migrated to GTK4. This project focuses on the GTK4 migration of the Sugar Shell. The work includes replacing deprecated GTK3 APIs, migrating container and layout APIs to GTK4 equivalents, updating event handling using GTK4 event controllers, migrating styling to GTK CSS, and updating display and geometry handling using modern GTK4 display APIs. The migration will be done incrementally, component by component, starting with core components such as the Frame, Home View, Activity Launcher, Journal, Clipboard, and Control Panel. Each component will be migrated, tested in a running Sugar session, and submitted as small patches to ensure that the Sugar Shell remains stable and usable throughout the migration process. By the end of the project, the Sugar Shell will run on GTK4, core components will be migrated to GTK4 APIs, deprecated GTK3 APIs will be removed from migrated components, and migration documentation will be provided to support the remaining GTK4 transition work in the Sugar project.

pythonjavascriptgtk++10
Student: Dev10-sys
Code
Proposal

KDevelop Integration with Arduino and embedded development

beginner
KDE•2016Varies90h (Small)

<h4>Abstract</h4> <p>The actual Arduino IDE, was initially created with <a href="https://www.java.com" target="_blank">Java</a> and is still a simple IDE that does not provides autocompletion, sentence errors, assembly visualizer, field for compiling and linking flags, syntax highlighting and other features present in both <a href="https://www.kdevelop.org/" target="_blank">Kdevelop</a> and <a href="http://www.qt.io/ide/" target="_blank">Qt Creator</a></p> <p>Some developers and <a href="http://www.hackvandedam.nl/blog/?p=762" target="_blank">educators</a> say that Arduino IDE isn't as good and comfortable as a development ambient for higher education and development. In order to the to fix this situations, the development of Arduino plugins for KDevelop, Qt creator, Visual Studio and Eclipse began, but generally the setup for such plugins is complicated and it's necessary a good understanding of these IDEs and OS's ambient functionality.</p> <p>The main goal of this proposal is to add a native support to KDevelop with embedded systems, such as Arduino and ARM processors. Using <strong><em>avrdude</em></strong>, <strong><em>OpenOCD</em></strong>, <strong><em>GDB</em></strong> and other tools that are used in development of embedded systems.</p>

c++qtcmake+2
Student: PatrickElectric
Code
Proposal

Incremental Global Routing on CUGR

advanced
The OpenROAD Initiative•2026Varies350h (Large)

OpenROAD's CUGR backend lacks incremental routing support, forcing a full re-route of the entire design after every Engineering Change Order (ECO) operation such as buffer insertion, buffer removal, gate upsizing or downsizing, and placement legalisation. On large industrial designs this can take tens of minutes per iteration. FastRoute, the other backend, already handles this correctly via the IncrementalGRoute class and GRouteDbCbk ODB callbacks that track only the subset of modified nets. This project brings full incremental routing parity to CUGR by implementing deleted net cleanup (removeNet), connecting all five ECO-triggered ODB callbacks to CUGR's dirty-net queue, ensuring only the correct subset of nets is re-routed per incremental pass, and scoping guide write-back to dirty and secondary overflow nets only, modelled on findRouting in FastRoute. Three pull requests implementing the core infrastructure have already been merged into upstream OpenROAD (#9671, #9759, #9866). Deliverables include the complete incremental CUGR flow, a regression test suite covering all ECO scenarios, incremental congestion view updates, and benchmarking data comparing incremental versus full re-route runtime and quality across reference designs.

pythonverilogc+++2
Student: Sparsh Karna
Code
Proposal

Upgrade WebdriverIO to the latest version 7 for all repositories

beginner
Wikimedia Foundation•2021Varies90h (Small)

<p>Project Summary</p> <p>Testing of software is important since it discovers defects/bugs before the delivery to the client, which guarantees the quality of the software. It makes the software more reliable and easy to use. Thoroughly tested software ensures reliable and high-performance software operation. Now to ease regression testing time and for better efficiency to validate complex scenarios automation is preffered.</p> <p>The Major Goal</p> <p>Currently mediawiki is using Webdriverio as a browser driver for our test automation framework which is at version 6 (exception: 2 are at V4). The goal of this project is to migrate them to version 7 (Latest) Which was released recently on Feb 9 , 2021. Also we need to perform cleanup and refactoring of the existing WebdriverIO code across all repositories. (Additional goals below).</p> <p>Features in new updates</p> <p>Stricter Protocol Compilance Test Coverage Reporting Dropped Node v10 support Improved google lighthouse Integration</p> <p>The Additional Goals:</p> <p>Enabling of video recording in all selenium test Sanitizing Page Object Imports across all repos. Extending the wdio.conf.js file so that the same file can be used/extended across all repositories.</p>

javascripthtmlphp+7
Student: Sahil Grewal
Code

YooHoo - The Perfect Chat Engine

beginner
Debian Project•2016Varies90h (Small)

<p>Project Details: YooHoo, is a interactive chat engine, which supports text, audio, video chats and file sharing. It is to facilitate one-to-one chats, group chats, create events and manage them online(assign tasks and schedule deadlines etc). It has also got a integrated set of bots, for mainly connecting with wiki.debian.org, packages.debian.org etc to provide instant help for queries, suggest apps etc. It also include provision for creating new bots using custom codes. The main aim of YooHoo is to create a collaborative environment for those who are working on Linux systems. With its in-build bots it can provide live assistance to users, suggest the best apps available for his needs, get latest releases and news, which can improve user experience a lot.</p> <p>Benefits to Debian: Will help to provide automated help to its users (by the bot) as well as ask new queries, report bugs etc, thus bridging the gap between a normal user and Debian system.</p> <p>Why Debian?: Well, Once you start exploring her, your curiosity never ends. Of all the other distros I have used, I learned more on Linux by using Debian. She is simple, minimalist and is highly educative in a learn by doing approach.</p>

cpythondjango+5
Student: Balu Menon
Code
Proposal
Showing 4513 - 4536 of 4718 Projects
187188189190191
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal