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

Inlay type hints for SourceKit-LSP

intermediate
Swift•2021Varies

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)

<p>Inlay hints take advantage of Swift's powerful type inference by visualizing inferred types throughout a Swift program in the editor. This makes it easier to read and understand Swift code, all while letting the programmer write concise code, without having to spell out every type. To achieve this, a custom LSP request is introduced that fetches the inferred types of unannotated variable bindings from the language server which, in turn, queries <code>sourcekitd</code> for the required information. The request will be called by the editor, e.g. VSCode, which will subsequently present the corresponding text decorations.</p>

llvmc++cmake+5
Student: Fredrik Wieczerkowski
Code
Proposal

Swift native implementation of a Memcached Client using SwiftNIO for the networking stack.

advanced
Swift•2023Varies350h (Large)

I will be developing a native Swift Memcached client using SwiftNIO to address the need for an efficient and user-friendly caching solution in Swift based applications. The goal is to provide a high performance client that integrates seamlessly with existing Swift ecosystems, simplifying the process of sending commands and receiving responses from memcached servers. Our focus is on implementing the Memcached meta protocol, request encoding, response decoding, and request pipelining, while the non-goals is to cover every memcached feature or command. This project aims to benefit developers by offering an asynchronous-first Swift API for essential memcached operations, ultimately enhancing the caching capabilities of their applications.

llvmc++cmake+5
Student: dkz
Code
Proposal

Key Path inference and diagnostic improvements

intermediate
Swift•2023Varies175h (Medium)

SE-0249 introduced key path expressions as functions to the Swift language, to allow Swift users to write a more concise \Root.value in place of the more verbose { $0[keyPath: \.<member>] } wherever key paths are used as literal expressions. During compilation, the key path expression root and value are sequentially type-checked to resolve a key path type from this context. However, the current design of how the type-checker evaluates key path component types, their relationships to each other, and key path capabilities results in incongruous compiler errors for otherwise valid Swift code. This proposal briefly explores how key path expressions are type-checked today and suggests how this type-checker process can be made more robust, dependable, and faster.

llvmc++cmake+5
Student: Amritpan Kaur
Code
Proposal

Archival and Restore Feature for SW360

intermediate
SW360•2026Varies175h (Medium)

SW360 instances running for years accumulate thousands of stale projects, components, and releases that slow down searches, waste disk space, and clutter the UI. Currently, the only cleanup option is permanent deletion with no undo. This project adds a reversible archival workflow. Admins select entities, export them as self-contained TAR.GZ bundles with all metadata and attachments, then remove them from the live database. A CouchDB registry tracks what was archived and by whom. To restore, admins upload the archive, preview contents with conflict detection, and selectively re-insert entities. Deliverables: archival.thrift service definition, backend Maven module with archive and restore logic, REST API endpoints, a frontend admin page with entity selection, registry table, and multi-step restore flow, plus unit and E2E tests."

javareactcouchdb+1
Student: Taanvi Khevaria
Code
Proposal

Improving the Debug Output Of The Type Inference Algorithm

intermediate
Swift•2022Varies175h (Medium)

Swift’s type inference algorithm allows us to write source code without explicit type notations. It is implemented using a type checker that breaks up the source code into subexpressions and generates their abstract type variables and type relationships to create a constraint system that maps out all of these components of the subexpressions of the source code and helps the compiler deduce the missing concrete type information from this context. These type variables, their interrelationships, and the final type-checked expressions can be printed as debug information to help compiler developers understand this process. However, the current debug output is hard to understand, wordy and repetitive, with a format that is difficult to follow. This proposal will reorganize and rewrite the debug output of the type inference algorithm to make it more human-friendly and improve the debugging experience for new and experienced Swift compiler developers.

llvmc++cmake+5
Student: Amritpan Kaur
Code
Proposal

Improve the display of documentation during code completion in SourceKit-LSP

intermediate
Swift•2025Varies175h (Medium)

Currently, SourceKit-LSP only shows the first line of the documentation for code completion items. Furthermore, it doesn’t support the Language Server Protocol’s (LSP) signature help request which provides information about the function or subscript being completed like alternative signatures, documentation, parameter list, and parameter-specific documentation. The goal of this project is to enhance how SourceKit-LSP displays documentation for code completion items by: 1. Providing the full documentation for code completion items rather than the first line only. 2. Implementing LSP’s signature help request to provide richer guidance for completing function/subscript signatures. The implementation will require changes in SourceKit-LSP and sourcekitd in the Swift compiler codebase. This will enhance the developer experience for Swift developers using SourceKit-LSP on editors like Visual Studio Code and Neovim aligning with Swift’s vision of cross-platform support.

llvmc++cmake+5
Student: Ahmed Elrefaey
Code

Improved Console Output for Swift Testing

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

This project enhances the console output experience for the Swift Testing framework by designing and implementing a new, two-phase console reporter. This architecture provides both real-time feedback during test execution (the "Live Phase") and concludes with a comprehensive, structured report (the "Summary Phase"). The primary focus during this GSoC project was the implementation of the Summary Phase, which includes: - A rich Hierarchical Summary that visualizes the relationship between test suites and individual tests. - A dedicated Detailed Failure Report providing clear, actionable information for debugging. - Intelligent cross-platform support, with an ASCII fallback for terminals with limited Unicode compatibility. Architecturally, the reporter was refactored to consume a serialization-based event stream (ABI.EncodedEvent). This was a significant technical pivot that decouples the reporter from the test runner, preparing it for future integration into an out-of-process "harness". The final deliverable is a robust, experimental implementation available behind a feature flag, with a clear roadmap for completing the Live Phase post-GSoC.

llvmc++cmake+5
Student: Tien Quoc Bui
Code
Proposal

GSoC 2026 Proposal: Remove Apache Thrift and Migrate to Direct Spring Service Calls

advanced
SW360•2026$6k–$13.2k350h (Large)

SW360 today uses Apache Thrift for backend-to-backend calls. That choice forces a Thrift toolchain and many .thrift IDLs, ships large WARs via shared Thrift servlet code, makes traffic hard to debug with normal HTTP tools, and limits standard metrics and load testing. Project goal is to migrate the backend incrementally to Spring Boot REST with a shared libraries/service-api contract (plain POJOs instead of generated Thrift types), WebClient from the resource-server, and a Converter pattern where backend-common still uses Thrift-shaped DB types, so each service can move without a big-bang rewrite. Health and Vendor are already implemented as proof of concept with benchmarks and parity checks. Deliverables: migrate all 23 Thrift-backed service clients, shrink/remove Thrift from the build, delete or retire IDLs and ThriftClients factory methods as each service lands, document the migration recipe and architecture tradeoffs (including optional gRPC for hot paths if mentors agree), keep the public REST/HATEOAS API stable for consumers, and finish with full-system tests, updated contributor docs, and final benchmarks. Work is phased by dependency tiers (standalone services first, Schedule and final cleanup last) on GSoC 2026’s extended coding period, with buffers for review and integration risk.

javareactcouchdb+1
Student: Shivamrut
Code

Improving Integration of SW360 with FOSSology

advanced
SW360•2025Varies350h (Large)

Currently, SW360’s integration with FOSSology is limited to only basic functionalities using outdated endpoints namely, triggering scans and checking scan status. This results in inefficient workflows, redundant uploads, lack of flexibility in scanning configurations, and restricted report formats. It also misses opportunities for reuse of scan data and lacks user-level attribution and secure token handling. This project and proposal aims to refactor and extend SW360's FOSSology integration by utilizing the modern RESTful API (OpenAPI v2 spec) offered by FOSSology. It will enable advanced functionalities such as: 1. Direct Source Uploads via POST /uploads 2. Checksum-Based Search and Reuse using /filesearch 3. Selectable Scanning Agents (e.g., Nomos, Monk, Reuser) 4. Multi-Format Report Generation (SPDX, CycloneDX, etc.) 5. User-Specific Token Support for secure and auditable API interactions These enhancements will be implemented through a modular, secure, and scalable API integration layer in SW360, with robust error handling, polling mechanisms, and extensibility for future API versions. Deliverables: 1. REST API Refactoring of SW360's FOSSology connector using modern v2 endpoints. 2. Efficient File Upload System with token-based authentication and job initiation. 3. Checksum Reuse Logic to avoid duplicate scans and utilize FOSSology’s “Reuser” agent. 4. Configurable Scanning Agent Support exposed via backend APIs. 5. Support for Diverse Report Formats, download mechanisms, and metadata linking. 6. Secure Token Management for both server-wide and user-specific workflows. 7. Robust Error Handling, retry logic, audit logging, and performance tuning. 8. Comprehensive Testing, documentation, and CI/CD pipeline integration.

javareactcouchdb+1
Student: Ritankar Saha
Code
Proposal

Debusine: live log streaming

intermediate
Debian•2026Varies175h (Medium)

Debusine currently only shows task logs after a task has fully completed. This means developers working with long-running jobs (such as package builds or test pipelines) have no way to monitor progress in real time or catch failures early. This project adds live log streaming to Debusine. The implementation follows a four-stage pipeline. On the worker side, the sub-process runner will be extended to capture stdout and stderr incrementally as a task runs, sending each line to the server over the existing WebSocket connection rather than waiting for the task to finish. On the server side, a handler will receive these lines and write them to a per-task Redis Stream, providing a persistent, ordered, low-latency buffer that supports multiple simultaneous readers. A server-side view will then expose these log lines to browser clients via Server-Sent Events or a WebSocket endpoint. As a stretch goal, the Debusine web UI will subscribe to that endpoint and display lines appearing on the task page in real time, with no page refresh required. Deliverables: - Worker-side incremental log capture and WebSocket emission, with full test coverage - Server-side Redis Stream ingestion, per-task key namespacing, and post-task flush to PostgreSQL - A server view that streams log lines to browser clients for running tasks - A browser-side UI update that shows live output on the task detail page using plain JavaScript, without any frontend framework

pythonjavascriptc/c+++8
Student: mo-ashraf
Code
Proposal

Migration of UI into React.js

intermediate
FOSSology•2021Varies175h (Medium)

<p>The UI Migration project is an effort focused on generating the new component-based architecture with the integration of the APIs. To make the project more <strong>efficient</strong> and <strong>easily accessible</strong>, an entire code base shift from Symfony-Twig to React.js is proposed. React.js features an incrementally adaptable architecture that focuses on declarative rendering and component composition. React.js component system will enable us to organize the current working APIs appropriately.</p> <p>The main <strong>objectives</strong> of this project are:</p> <ol> <li>Working on good interactive design, with a modern look.</li> <li>Integrating the APIs to the new component-based UI structure.</li> <li>Seamless routing and page transitions.</li> <li>Giving the power of the node engine to our UI. Making all NPM accessible.</li> <li>Write appropriate documentation.</li> </ol>

linuxpostgresqlc/c+++7
Student: Shruti Agarwal
Code
Proposal

Modernizing OpenELIS Frontend with TypeScript and Performance Optimization

advanced
OpenELIS Global•2026Varies350h (Large)

The current OpenELIS React frontend is primarily written in JavaScript and faces challenges in maintainability, scalability, and performance as data complexity increases. This results in inconsistent type usage, increased bugs, and inefficient rendering in data-heavy workflows such as patient management, sample tracking, and result entry. This project aims to modernize the frontend by incrementally migrating the codebase to TypeScript and applying proven React performance optimization techniques. The migration will introduce a centralized type system for API models, forms, and reusable components, ensuring consistency and reducing duplication across the codebase. The project will follow a phased approach: first establishing a strong TypeScript foundation with shared type definitions, then incrementally migrating utilities, components, and high-impact screens. In parallel, performance optimizations will be implemented using profiling-driven techniques such as memoization, virtualization for large datasets, improved server-state handling, and code splitting. Deliverables include: - Incremental migration of frontend codebase to TypeScript - Centralized and reusable type definition system - Performance improvements in key workflows - Reduced bundle size and improved rendering efficiency - Documentation and migration guide for future contributors This project will significantly improve the maintainability, developer experience, and performance of the OpenELIS frontend, making it more scalable for future growth.

postgresqljavascriptjava+2
Student: Manroop Singh
Code

User Profile App using ReactJs

intermediate
Health Information Systems Programme•2016$3k–$6.6k175h (Medium)

<h3>User Profile App using ReactJS</h3> <p>As a part of modernising the architecture of DHIS 2, we are in the process of rewriting server based system maintenance apps as modern client side web apps. While development of settings app, maintenance app and app-management app is nearly complete, the User Profile App is yet to get started. As part of the GSOC 2016, I propose to develop user profile application for DHIS2. This app will essentially provide a user interface to DHIS2 users to -</p> <ul> <li>View and edit user profile details.</li> <li>View and edit user account settings.</li> </ul> <p>I will be using ReactJS view library and will follow a Flux based architecture to write this app. The application's architecture should be such that we can reuse most of its components in other apps using D2-UI. It is important that the overall look and feel of this app matches that of the other new client-side applications. D2 should be extended by adding methods and properties so that it is capable of performing all operations required to view and update user profile and account settings.</p>

javascriptandroidjava+2
Student: adhbh
Code
Proposal

Adding search to more moodle components

advanced
Moodle•2016Varies350h (Large)

<p>The project aims to extend the scope of Moodle's GlobalSearch to more moodle components. The GlobalSearch feature enables the user to search faster and better with the help of an external dedicated search server. Since GlobalSearch is pluggable, the user organisations have the liberty to use the search platform of their choice. The default search server is Apache Solr.</p> <p>Search platforms like Apache Solr and ElasticSearch index the data entities to be searched in a NoSQL schema format and provide much higher performance while performing search queries as compared to querying database when it comes to scalability. They store the fields of an indexed document using Trie data structures in accordance with some key attributes configured in their schema files.</p> <p>The components which are to be covered are:</p> <ul> <li>Courses</li> <li>Users</li> <li>Database entries</li> <li>Messages</li> </ul>

mysqlpostgresqljavascript+5
Student: Devang Gaur
Code
Proposal

Dev Server Refactor

intermediate
webpack•2019Varies175h (Medium)

<p>The Webpack Dev Server is designed to make development of Webpack projects efficient, customizable, and possible on older browsers. During this project, I will introduce native WebSockets on the client and ws on the server as the new default Dev Server implementation, while also allowing the user to provide their own client-server implementation. I will improve upon API/CLI uniformity, which has made the Dev Server difficult for users to work with in the past. Finally, I will fully implement the Dev Server into webpack-cli, and I will create core Webpack features that allow the Dev Server to more easily interact with the Webpack Compiler.</p>

javascriptnode.jsweb development+6
Student: Kirill Nagaitsev
Code
Proposal

Improve tests for all REST API endpoints

intermediate
SW360•2025Varies175h (Medium)

This proposal aims to improve the testing framework for SW360’s REST API endpoints by addressing limited test coverage, insufficient integration tests, and outdated testing workflows. The project will focus on writing comprehensive unit tests for CRUD operations and edge cases, developing integration tests for multi-endpoint workflows, and creating reusable utilities for database mocking and error simulation. Additionally, CI/CD pipelines will be automated with tools like JaCoCo for test coverage tracking and regression prevention. Deliverables include a robust test suite, enhanced testing infrastructure, automated pipelines, and detailed documentation to simplify onboarding and contributions. These improvements will make SW360's APIs more reliable, scalable, and maintainable for the developer community.

javareactcouchdb+1
Student: Rohit Borra
Code
Proposal

Implement Incremental Re-Parsing in SwiftParser

advanced
Swift•2023Varies350h (Large)

Considering the performance, instead of reparsing the entire file every time, we could speed up the parsing procedure with the information provided by old AST, which is an ability provided by the old parser. In the old implementation, this feature was only applied to CodeBlockList and MemberDeclList. In the new implementation, It would be nice to apply node reusing to other syntax collections e.g. exprList, functionParameterList, etc. Also, It would be good to allow more fine-grained reusable nodes via expanding the definition of nodeAtCursorCanBeReused to allow reusing nodes such as FunctionDeclSyntax where only identifier is changed.

llvmc++cmake+5
Student: Ziyang Huang
Code
Proposal

DocC Language Features in SourceKit-LSP

intermediate
Swift•2026Varies175h (Medium)

This project aims to extend SourceKit LSP to add DocC Language features like go-to-definition and diagnostic support for missing or broken symbol links. It also enhances the documentation preview by making it interactive with clickable symbol links and web URLs, along with syntax highlighting for .tutorial and .md files.

llvmc++cmake+5
Student: Padmashree S S
Code
Proposal

Integrating libSyntax with the Rest of the Compiler Pipeline

intermediate
Swift•2019Varies175h (Medium)

<p>Over the last couple of years, the Swift compiler has gained a new library called libSyntax. Its purpose is to represent the syntax of Swift source code with full fidelity (including white-space), enable structured editing and provide immutable, thread-safe data structures.</p> <p>This paper proposes that the Swift parser fully embraces the new libSyntax library in its parser and stops emitting ASTs. This will allow more parts of the compiler pipeline to eventually leverage the capabilities of the new library.</p>

llvmc++cmake+5
Student: Jan Svoboda
Code
Proposal

Bootstrapping SwiftSyntaxBuilder

intermediate
Swift•2022Varies175h (Medium)

Providing excellent tooling for Swift often involves operating on Swift syntax trees directly. The swift-syntax library serves this purpose by providing a Swift representation of syntax trees, along with facilities to parse and generate Swift code. To make code generation especially convenient, the library includes a Domain-Specific Language (DSL) for building syntax trees that, however, currently relies on external tooling to generate a large part of its own definitions. To test the DSL on a non-trivial codebase and to make it production-ready, we will rewrite the syntax builder in itself, generating its sources using its own DSL and thereby bootstrapping its implementation.

llvmc++cmake+5
Student: Fredrik Wieczerkowski
Code
Proposal

Swiftly Integration in VS Code

intermediate
Swift•2025Varies175h (Medium)

This project aims to integrate Swiftly with the Swift Extension for VSCode. It should allow users to install Swiftly and Swift toolchains in the VSCode editor toolchains directly within the VSCode editor. Currently, we have the “Swift Extension of VS Code,” which provides code completion and LSP integration, error annotations with applicable suggestions, automatic generation of launch configurations for debugging, automatic task creation, Swift PM integration, and test explorer view. Since different projects may require different versions of Swift toolchains, we want to integrate with Swiftly to provide a seamless toolchain selection experience in VSCode.

llvmc++cmake+5
Student: Priyambada Roul
Code
Proposal

Localization of Compiler Diagnostic Messages

intermediate
Swift•2020Varies175h (Medium)

<p>Diagnostics play a vital role in a programming language experience. It’s vital for developer productivity that the compiler can produce proper guidance in any situation, especially incomplete or invalid code through messages. However, the diagnostic messages might be helpful in much time; for the non-English speakers, it’s not.</p> <p>As a step towards the goal of making Swift programming language more accessible for non-English speakers, this proposal extends the Swift compiler to allow it to produce localized diagnostic messages.</p>

llvmc++cmake+5
Student: Hassan ElDesouky
Code
Proposal

Shared Storage for Property Wrappers

advanced
Swift•2021Varies350h (Large)

<p>Property Wrappers are responsible for wrapping common getting and setting boilerplate and also for storing any auxiliary helpers. Often, these helpers are the same across different instances of the wrapper. Thus, having to store it in each individual wrapper instance is a waste that should be avoided. We can solve this by introducing a static storage that is shared across instances, within the scope of where they are declared. Thus, providing a tool for property wrapper authors to optimize their wrapper abstractions.</p> <pre><code>@propertyWrapper(shared: Storage) struct Clamped { private var value: Value struct Storage { let range: ClosedRange&lt;Value&gt; init(_ range: ClosedRange&lt;Value&gt;) { // ... } } // wrappedValue would be accessed through a subscript subscript(shared storage: Storage) -&gt; Value { get { value } set { value = storage.range.clamping(newValue) } } } </code></pre>

llvmc++cmake+5
Student: Isabel Lima
Code
Proposal

A "Bite-Sized" BitArray

intermediate
Swift•2021$3k–$6.6k175h (Medium)

<p>View the final API Review here: <a href="https://forums.swift.org/t/bit-array-and-bit-set-api-review-the-end-of-a-gsoc-project/51396" target="_blank">https://forums.swift.org/t/bit-array-and-bit-set-api-review-the-end-of-a-gsoc-project/51396</a></p>

llvmc++cmake+5
Student: Mahanaz Atiqullah
Code
Proposal
Showing 289 - 312 of 3339 Projects
1112131415
Proposal
Proposal
Proposal