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

Interactive mode for swift CLI tool ArgumentParser

intermediate
Swift•2022Varies

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)

For this project, we would design and implement an interactive mode for command-line tools built using ArgumentParser that prompts for any required arguments not given in the initial command. In the past, users would get lengthy error messages and help text when the command is incomplete. Interactive mode will reduce duplication and provide a conversational CLI which is both easier to write and easier to read.

llvmc++cmake+5
Student: Kth
Code
Proposal

Quick navigation in DocC Render

intermediate
Swift•2022Varies175h (Medium)

DocC Render is an open-sourced project that let us visualize `.doccarchive` on the web, it renders the compiled Swift codebase documentation in a clean and standardized UI making it easier for developers to learn, review and share packages and frameworks documentation. The codebase documentation can get very large easily and right now the DocC rendered website only provides certain filter and search capabilities through the sidebar, but besides that, there's no convenient way to explore the docs. In this project we are going to design and implement the “Quick Navigation” feature into swift-docc-render, allowing users to navigate and discover documentation symbols and files easily. Similar to "Open Quickly" in Xcode and other web-based documentation sites we will let the user type and find what they are looking for through some cool capabilities including fuzzy search, quick access to recent symbols, and keyboard navigation.

llvmc++cmake+5
Student: Sofía Rodríguez
Code
Proposal

Task and TaskGroup Tracking for Swift Concurrency

advanced
Swift•2026Varies350h (Large)

Swift's concurrency runtime has no mechanism to enumerate live Tasks and TaskGroups. When a program using async/await stalls, existing tools such as thread backtraces, Instruments, LLDB are silent about the suspended tasks that are the likely cause. Instruments records task lifetimes after completion; there is no API, debugger command, or crash report field that answers "what tasks exist right now and what are they waiting on?" This project implements a global registry of live AsyncTask and TaskGroup instances inside the Swift Concurrency runtime. The core challenge is doing this without introducing unacceptable synchronisation overhead on every task creation and destruction, a hot path in any concurrent Swift program. I will implement and benchmark at minimum two candidate data structures: a sharded-mutex intrusive list (using PrivateStorage, which is opaque externally and safe to extend without breaking ABI) and a lock-free Treiber stack alternative. Deliverables: A working registry implementation with hooks in swift_task_create_commonImpl and AsyncTask::~AsyncTask() A design document comparing candidate data structures with measured overhead against the existing TaskGroups.swift and AsyncTree.swift benchmark suite Signal-safe crash backtrace integration listing live tasks on crash LLDB Python macros for interactive task inspection.

llvmc++cmake+5
Student: Ege Kaya
Code
Proposal

SwiftPM support for Swift scripts

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

<p>This proposal aims to bring scripting support to SwiftPM. The goal for GSoC is some kind of proof-of-concept and is expected to be the foundation of a full implementation of this feature. The outcome is expected to be a prototype of the new <code>swift-script</code> tool, which has a limited set of basic operations implemented like <code>run</code> and <code>reset</code>. There will also be a new flag for Swift Driver which enables a shortcut to the feature through <code>swift</code> command.</p>

llvmc++cmake+5
Student: Yongrong Chen
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

Integration of SW360 and LicenseDB

intermediate
SW360•2026Varies175h (Medium)

SW360 currently imports license and obligation data through five disconnected paths with no coordination between them, meaning multiple instances can hold different obligation text for the same license with no way to detect the gap. This project makes LicenseDB the single authoritative source by implementing scheduled REST based synchronization. It covers paginated license and obligation sync, incremental daily updates via the audit log, field-level mapping that preserves SW360-specific compliance fields, read-only gating of legacy import paths, and CouchDB-first lookup for CLI attachment processing. Deliverables include JWT authentication, automated daily scheduling via ScheduleHandler, admin REST endpoints for sync control and health monitoring, encrypted credentials, circuit breaker and rate limiting, a migration guide, and test coverage.

javareactcouchdb+1
Student: Sandyp
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

Write a Swift code generator to support the creation of SAM deployment descriptor

intermediate
Swift•2024Varies175h (Medium)

Deploying AWS Lambda functions using AWS SAM (Serverless Application Model) requires manual creation of a deployment descriptor, posing challenges for Swift developers due to learning a new DSL and adopting new tools like SAM CLI and Docker. To simplify this process, the community proposed a Swift-based DSL and a Swift package plugin. However, these solutions rely heavily on accurately mimicking the evolving SAM AWS deployment descriptor. To address this, this project proposes to automatically generate the AWSLambdaDeploymentDescriptor library based on the SAM template definition. That generated code is used by the Swift-based DSL to create SAM YAML templates required to deploy Lambda functions and their dependencies to AWS.

llvmc++cmake+5
Student: Esraa Eid
Code
Proposal

LTO support for Swift

advanced
Swift•2020Varies350h (Large)

<p>Swift supports multiple levels of optimizations per single module. This project aims to achieve LTO support for Swift at LLVM level and at Swift’s intermediate representation level to do more aggressive optimization across modules.</p> <p>This proposal suggests language-agnostic LTO support and linker plugin implementation for Swift specific LTO.</p> <p>The linker plugin will be able to accept serialized Swift Intermediate Language (SIB) files for multiple modules and performs cross-module optimization passes (e.g. Dead Code Elimination, Inlining).</p> <p>As a result, it’s expected to achieve significant binary size reduction and runtime performance improvements.</p>

llvmc++cmake+5
Student: kateinoigakukun
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

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

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

Alive for SIL

intermediate
Swift•2021Varies175h (Medium)

<p>The <a href="https://docs.google.com/document/d/1dOK9FYKf2egZcYqrR3rdtF8o2ykTdVxwuuwZcrs5lwQ/edit#heading=h.b4gt1ulsb82o" target="_blank">Alive for SIL</a> project aims to build a tool that will find errors in optimizations performed by the Swift compiler.</p> <p><a href="https://swift.org/swift-compiler/#compiler-architecture" target="_blank">SIL</a> (a.k.a. Swift Intermediate Language) is an IR (a.k.a. intermediate representation) used within the Swift compiler between the Swift AST and LLVM IR. SIL enables the Swift compiler to perform Swift-specific optimizations.</p> <p><a href="https://sf.snu.ac.kr/publications/alive2.pdf" target="_blank">Alive</a> is a tool that formally verifies the correctness of optimizations performed on LLVM IR and produces counterexamples when such optimizations are incorrect. For example, if an optimization accidentally adds undefined behavior into a program, then Alive2 would be able to find this error and produce an example that exposes the undefined behavior.</p> <p>This project aims to extend Alive to verify the correctness of optimizations performed on SIL.</p>

llvmc++cmake+5
Student: Justin Fargnoli
Code
Proposal

HTTP Server Implementation

intermediate
The Linux Foundation•2023Varies175h (Medium)

This project is proposed because of the need for a fully-integrated HTTP server in Zephyr that can replace the deprecated CivetWeb module. The proposed solution is to prototype a basic HTTP 2.0 server using POSIX APIs and then port it to Zephyr. The server will take advantage of Zephyr's existing building blocks, including the ZTest Framework, mbedTLS libraries, Kconfig ... The project's deliverables include a basic HTTP server, porting the server to Zephyr, and creating a Test Plan to demonstrate mandatory features such as REST API, TLS, and Compressed Resources in Memory (CRiMe). Additionally, we will demonstrate HTTP server functionality with one of Zephyr's supported boards and Qemu.

cpythonmysql+7
Student: Emna Rekik
Code
Proposal

Improving the VM Profiler

intermediate
Pharo Consortium•2017Varies175h (Medium)

<h3>Improving the VM Profiler</h3> <p>The current VM profiler is a sampling profiler cadenced at 1.3GHz tracking down where the time is spent in the C code of the VM (for the interpreter and the GC) and in the machine code zone (for the code generated by the JIT). The VM profiler cannot track down precisely where the time is spent when executing the code generated by the JIT. It can track down in which methods the time is spent, but it cannot track down in which part of those methods the time is spent.</p> <h3>Goals</h3> <ul> <li><strong>Port the VM Profiler to Pharo</strong> (it only works in Squeak for the moment) </li> </ul> <p>By making sure the UI stays independent and by patching all the uses of the library OSProcess to make it work in both Squeak and Pharo</p> <ul> <li><strong>Get a more detailed profiling</strong> </li> </ul> <p>By using the JIT API to map machine code instruction pointer to bytecode program counter, to be able in the end to show in which bytecode range of methods the time is spent instead of only in which methods the time is spent</p>

smalltalkroassalpolymath+7
Student: SophieK
Code
Proposal

Background-powered Components

intermediate
MIT App Inventor•2017Varies175h (Medium)

<p>Components are the building blocks of app inventor. They can be visible i.e. they are part of UI interface or they can be non visible i.e they are not part of the UI screen but provide access to built-in functions of the device. All components in app inventor are part of some screen or activity which means that if the screen is not visible or the screen is destroyed by the Android system, the components stop running. An example of this is the Pedometer component which stops running when the phone screen is off. Ideally, a pedometer app would want to keep running once started in the background until the user of the app explicitly stops it. To enable such behavior it is necessary to run such components in a background process and re-start the process every time the system kills it.</p>

javagwtgoogle app engine+7
Student: Joydeep Mitra
Code
Proposal

Visible Component Extensions

intermediate
MIT App Inventor•2020Varies175h (Medium)

<p>Currently, extensions are limited to just non-visible components. Due to this, extensions can't be dragged into the screen designer. To work around this, extension developers have to get a reference to a visible component as parent under which they create UI views. This, however, defeats the idea of App Inventor, which allows the users to create their UI of their apps using the concept of WYSIWYG. My proposal to solve this problem is to have a generic <code>MockVisibleComponentExtension</code> which can be dragged into the designer. The extension will be just a visible component as opposed to non-visible component. This allows the extension to be placed under a <code>ComponentContainer</code> under which the extension can create its views. This allows the users to view a clear hierarchy of their app's UI when using "visible" extension. Then, there will also be a need for <code>MockComponentContainerExtension</code> into which any visible component/extension can be placed.</p>

javagwtgoogle app engine+7
Student: Pavitra Golchha
Code
Proposal

WebView Components UI

intermediate
Chromium•2021Varies175h (Medium)

<p>Android WebView is an Android framework component that is developed under the Chromium Project. WebView is embedded inside other Android apps but it has its own standalone DevTools Android app that is bundled with the APK.</p> <p>The project aims to implement a Components UI to the aforementioned.</p> <p>This will make the dynamically installed components more easily accessible to developers and testers in comparison to the adb shell. This UI will be similar to chrome://components page in the Chrome Browser.</p>

pythonjavascriptjava+2
Student: A5hut05h
Code
Proposal

Processing Language Server : Processing

beginner
Processing Foundation•2019Varies90h (Small)

<p>Processing Language Server focuses on creating a Language Server Protocol (LSP) implementation for Processing Programming Language. PDE is currently built using Java and using custom components of the Swing Framework, which is ~ deprecated. The long term goal of Processing is to replace this with a JS based IDE to bring in more contributors and to make building UIs simple. While planning on building such IDE, LSP is of significant importance for any language that the IDE relays on. Since Processing is the targeted Programming language, it’s quite important to build a Language Server Protocol for the same. This shall act as a benchmark for all the crucial activities of the IDE such as auto-completion, go-to-definition, hover-insights and so on. LSP will also help in easy and seamless integration of the above functionalities in any editor such as Atom, VScode, etc.</p>

pythonjavascriptandroid+6
Student: Syam Sundar K
Code
Proposal

GDScript Language Server

intermediate
Godot Engine•2019Varies175h (Medium)

<p>Integrated script editor in Godot lacks features found in editors like VS Code, Sublime, Emacs, etc. These editors are also more popular among developers and therefore are better to switch for usability. However, to implement core functionalities such as - Diagnosis, Registering custom symbols, jump to definition, etc a Language Server structure has to be adopted. For example, the client (say vs code) will communicate the godot language server to give desired result.</p> <p>Microsoft's Language Server Protocol (LSP) is flexible and powerful to implement these functionalities. It also supports many editors - VS Code, Atom, Sublime, etc. Hence, instead of writing complete extensions for each editor (client) using LSP servers can be reused while the client which is an editor extension has to be only re-written.</p>

openglgithubc+++7
Student: Ankit Priyarup
Code
Proposal

iOS Implementation of Menu Component

intermediate
MIT App Inventor•2025Varies175h (Medium)

This proposal aims to implement the Menu, Sidebar, and Floating Action Button (FAB) components in iOS for MIT App Inventor, ensuring feature parity with Android as introduced in PR #2299. The Menu Component will introduce a dropdown-style menu supporting nested items, icons, and keyboard navigation. The Sidebar Component will provide a sliding navigation panel with swipe gestures, tap-to-close functionality, and essential navigation links like Home, Profile, Settings, and Logout. The Floating Action Button (FAB) will be a circular, floating button positioned at the bottom-right, supporting custom actions, animations, and a shadow effect for a modern UI experience. A key aspect of this project is ensuring feature parity with Android, maintaining UI/UX consistency across both platforms. I chose this project because it bridges the gap between iOS and Android, ensuring that MIT App Inventor provides a seamless cross-platform experience. It also enhances user experience by introducing smooth, intuitive navigation and interactions, making iOS-built apps more functional and engaging. Additionally, this project will expand MIT App Inventor’s capabilities by adding essential missing features, making the platform more versatile and user-friendly. The estimated timeline for this project is 175 hours, covering implementation, testing, and final integration. Upon completion, this update will significantly enhance MIT App Inventor’s iOS version, making it a fully-featured, cross-platform development tool that aligns with modern app-building standards.

javagwtgoogle app engine+7
Student: Kasy
Code
Proposal

Implement Visualization Component

intermediate
MIT App Inventor•2019Varies175h (Medium)

<p>Right now, MIT App Inventor is short of components that allow to visualize data using charts. This project aims to implement entirely new components that allow displaying the data visually, such as through pie charts, bar charts, scatter charts or radar charts, while also providing various customization functionality to allow the user to adapt the components to their needs.</p>

javagwtgoogle app engine+7
Student: Evaldas Latoškinas
Code
Proposal

Stream processing support for FasTensor library.

intermediate
UC OSPO•2024Varies175h (Medium)

I will implement stream processing support for FasTensor library. Stream processing enables online processing of live data as it arrives on the File System from various data producers. Th Big Plan: 1. A directory monitoring service will monitor file addition or removals of specified pattern. 2. A dynamic stream object which provides iterators that return file in a stream in specified order and also combine multiple streams. 3. A rich set of stream handling components, each with a unique set of concerns and guarantees, that enables stream-specific functions like read and write in a fault-tolerant and robust manner. Deliverables: 1. A rich interface to compose streams from various data producers. 2. A fault-tolerant and robust mechanism to read, write, and manage streams in a big data environment.

pythonc/c++visualization+5
Student: Aditya N.
Code
Proposal

Adding a return channel to Icecast server

intermediate
Xiph.Org Foundation•2021Varies175h (Medium)

<p>Icecast Server is used as a streaming server to broadcast to various listeners. A return channel allows for possibility of receiving feedback from listeners. This will make the streams interactive for conducting polls etc. The project aims to develop this return channel from listeners to source.</p>

rustassemblyarm+2
Student: Vishal Mishra
Code
Proposal
Showing 313 - 336 of 3339 Projects
1213141516