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

Digital Filter Block Implementations in MyHDL and PyFDA Integration

intermediate
Free and Open Source Silicon 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 →
175h (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
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

Device-Under-Test Python Typing Stub Generator for cocotb tests

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

This project aims to create a tool that automatically generates Python typing stubs for the Device Under Test (DUT) in cocotb-based hardware verification testbenches. By leveraging cocotb’s existing introspection capabilities, the tool will produce .pyi stub files describing the DUT’s interface – its hierarchy of modules and signals – in a statically typed fashion. These stubs will enable IDE features like auto-completion via VS Code’s Pylance and allow static type checkers such as mypy to catch errors in testbench code, significantly improving the hardware verification development experience​. The generated stubs will mirror the HDL design’s structure (with considerations for hierarchical vs. flat representations) and provide a structured abstraction of the DUT interface that can even be used for mocking or unit-testing components of the testbench. Initially, the stub generator will rely on runtime cocotb introspection only, but it will be designed with extensibility in mind, so that future enhancements (e.g., integrating a SystemVerilog language server like slang for richer type info) can be incorporated​. Over a 175-hour Google Summer of Code timeline, the project will deliver a working stub-generation utility, along with documentation, tests, and integration into the cocotb ecosystem, providing a concrete benefit to the open-source hardware verification community.

pythonjavascriptfpga+11
Student: chaitanyasharma
Code

Expansion of Swift Macros in Visual Studio Code

intermediate
Swift•2024Varies175h (Medium)

“Implementing a Code Action in Visual Studio Code to show the expansion of a Swift Macro in a peeked editor”. Swift Macros allow the generation of source code at compile time. While this provides concise code and avoids repetition of common paradigms, understanding the source code can become harder if it is unknown what the macro expands to. Visual Studio Code using the Swift Extension currently has limited ability to show the code generated by a macro by invoking a code action that replaces the macro by its generated code inside the current source file. The project’s goal is to implement a code action to show the macro-generated code without modifying the current source file. This includes the implementation of a request in sourcekit-lsp to compute the contents of the macro expansion and support in the Visual Studio Swift Extension to display that content. As a stretch goal, Visual Studio Code should also offer semantic functionality like jump-to-definition inside the macro expansion and allow the expansion of nested macros. *Deliverables*: 1. An Expand Macro Code Action in VS Code that shows the generated contents of a swift macro in a peeked editor 2. Support for Semantic Functionality such as jump-to-defintion, hover, syntax highlighting in the peeked editor 3. Allow expanding macros generated from macro in the peeked editor i.e. Nested Macro Expansion 4. Add a standard request support for other LSP-based editors giving them ability to expand macros upto the first level.

llvmc++cmake+5
Student: Lokesh T R
Code
Proposal

Rewriting Esoteric, Error-Prone Makefile Tests Using Robust Rust Features

beginner
The Rust Foundation•2024Varies90h (Small)

tests/run-make contains a heaping collection - 349 to be precise - of Makefiles containing ancient and difficult to understand test scripts. As a result, Rust maintainers may struggle to understand why these tests fail and how to patch their code appropriately. This project aims to rewrite these tests in robust, documented rmake.rs files, backed up by a supportive and easy to understand run-make-support support tool.

pythonrust
Student: Julien Robert
Code
Proposal

Pydata/Sparse: Merge lattices to enable C++ compile-time dispatch of sparse ndarrays

intermediate
Python Software Foundation•2023Varies175h (Medium)

There is currently no robust and unified sparse ndarray library that is compliant with the numpy API. This prevents the substitution of sparse arrays for dense arrays when needed in many data science workflows. PyData/Sparse is a repository that presents an opportunity to address these issues. In order to do so, there needs to be a C++ implementation of a code-generation algorithm that can generate efficient code for any type of sparse tensor operation. This abstraction allows one to maintain a relatively small piece of code that enables functionality for an exponential number of different sparse array format operations. The main objective of the project is to implement, test and document the merge lattice and its related data structures and algorithms that are vital for code-generation. This will result in a generalizable code-generation algorithm that can be applied for implementing a variety of different sparse ndarray formats that work together. This will involve interfacing heavily with the existing C++ code and its implemented templates to add functionality that constructs and manipulates a merge lattice, which is a useful abstraction in code-generation for sparse tensor algebra operations. As a few stretch goals, I plan on: i) implementing abstractions of what a sparse array is and what operations can be done that leverage this underlying core API, ii) finishing the co-iteration algorithm to account for non-unique and non-ordered levels and iii) begin work on the actual code-generation algorithm that leverages the merge lattice.

pythonmercurialjavascript+3
Student: adam2392
Code

Workflow engine

Intermediate
•Varies175h (Medium)

Integrate a new architectural component into Meshery: a workflow engine. This project involves shifting Meshery off of bitcask and off of sqlite over to postgres using gorm (golang). Interns will familiarize with concepts of orchestration engines, including chaining workflows, and content lifecycle management.

TBA
Proposal

Introduce an ABI lowering library

intermediate
LLVM Compiler Infrastructure•2025Varies175h (Medium)

The current implementations of the LLVM Project, have a drawback that every language frontend that wants to support Foreign Function Interface(FFI) into C code needs to implement Application Binary Interface(ABI) handling logic by itself. This leads to tremendous duplication of efforts and leaves the chance of potential inconsistencies. The aim of this project is to create a comprehensive ABI library housed within LLVM which would encapsulate the details of various platform specific calling conventions, argument passing strategies and return value handling.

cllvmc+++3
Student: Narayan Sreekumar
Code
Proposal

Improve Clang-Doc

intermediate
LLVM Compiler Infrastructure•2024Varies175h (Medium)

Clang-Doc is a documentation generator developed on top of libtooling developed as an alternative to Doxygen. Development started in 2018, and continued through 2019, however it has since stalled. Currently, the tool can generate HTML and markdown but the generated output has usability issues. Issues include, not supporting all C++ constructs, lack of ability to render in markdown and many more. This project aims to address the pain points regarding Clang-Doc, which will improve the output of Clang-Doc significantly.

cllvmc+++3
Student: Peter Chou
Code
Proposal

Modules Build Daemon: Build System Agnostic Support for Explicitly Built Modules

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

This project aims to implement a daemon that serves as a build system manager for modules, providing support for explicitly built modules irrespective of the build system. By simply incorporating a single command line flag, each Clang invocation registers its translation unit with the daemon, which then scans the unit's dependencies. As translation units are registered and analyzed, the daemon constructs a dependency graph for the entire project. Concurrently, it utilizes the emerging graph to schedule and build each module's AST. This approach allows for a single, comprehensive entity to effectively coordinate and manage the build of modules throughout the entire build process.

cllvmc+++3
Student: Connor Sughrue
Code
Proposal

Add DWARF Support for yaml2obj

intermediate
LLVM Compiler Infrastructure•2020Varies175h (Medium)

<p>LLVM offers 2 useful YAML tools, yaml2obj and obj2yaml. The former one reads YAML files and emits object files, e.g., ELF, COFF and MachO. The latter one does the reverse, reads object files and emits YAML files. We use these tools to write unit tests for binary tools, e.g., llvm-objdump, llvm-nm, llvm-readelf, as YAML is easier to read and edit than raw assembly codes and pre-built binaries. More importantly, YAML keeps our tests code base maintainable. However, yaml2obj currently doesn’t support generating DWARF sections very well (we have to hardcode the Content field of DWARF sections and it is not intuitive). This project aims to add DWARF support for yaml2obj (ELF part), which will ease our pain crafting DWARF tests.</p>

cllvmc+++3
Student: Xing GUO
Code
Proposal

Warn if virtual calls are made from constructors or destructors

intermediate
LLVM Compiler Infrastructure•2017Varies175h (Medium)

<p>In C++, virtual functions let instances of related classes have different behavior at run time. Pure function called from constructors and destructors will make the C++ program crash and virtual function called from constructors and destructors may not do what you expect. This proposal is about implementing a path-sensitive checker to find virtual calls made from constructors and destructors.</p>

cllvmc+++3
Student: Xin Wang
Code
Proposal

Polly as an Analysis Pass in LLVM

advanced
LLVM Compiler Infrastructure•2016Varies350h (Large)

<p>The Polyhedral framework provides an exact dependence analysis, which is more powerful than conventional dependence testing algorithms. Currently, LLVM mainline lacks a powerful dependence analysis framework, and at the same time, Polly’s (a high level data locality optimizer based on polyhedral framework) dependence analysis is suitable for many transformation passes in LLVM like Loop Vectorization, Loop Versioning, Modulo Scheduling, Loop Nest Optimizations, etc. I want to provide an API to Polly such that its precise dependence analysis can be used as an Analysis pass within LLVM's transformation passes.</p>

cllvmc+++3
Student: Utpal
Code
Proposal

Adapting IR Load Semantics to Freeze All or Freeze Only Uninitialized Data

advanced
LLVM Compiler Infrastructure•2023$6k–$13.2k350h (Large)

This proposal outlines a continuation of the Google Summer of Code (GSoC) 2022 topic to move uninitialized memory to poison semantics. Starting with GSoC 2022 and continuing over the last year several potential solutions have been developed and shared with the community via patches and RFCs. This has helped to build further understanding of both front-end and internal LLVM limitations. Based on the latest RFC two possible semantic solutions have been identified that allow loads to migrate to poison by default and provide backward compatibility with the current load undef semantics. This is accomplished by either freezing all bits regardless of initialization state or byte-level freezing based on initialization state. By implementing both solutions real-world performance metrics and maintenance impact can be evaluated by the LLVM community. This work will increase use of poison semantics further contributing to the eventual deprecation of undef.

cllvmc+++3
Student: John McIver
Code

Tutorial development with clang-repl

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

This project aims to develop tutorials demostrating the current capabilities of clang-repl. It also aims to investigate and research the requirements for adding clang-repl as a backend to xeus-cling. Add support for Xeus with the newly added clang-repl which is inspired from cling. The need for clang-repl is that it presents opportunities for rigorous open source development. However even though it is inspired by cling, not all of clang-repl and cling are same i.e. they are similar but work needs to be done to add xeus protocol support for clang-repl.

cllvmc+++3
Student: Krishna Narayanan
Code
Proposal

Shared Memory Based JITLink Memory Manager

advanced
LLVM Compiler Infrastructure•2022Varies350h (Large)

When a separate executor process is used with LLVM JIT, the generated code needs to be transferred to the executor process which is done by the JITLinkMemoryManager. The current implementation uses ExecutorProcessControl API (an RPC scheme) to send the generated code which goes through pipes or network sockets. The goal of the project is to transfer it through an operating system provided shared memory regions for better performance, when both the JIT process and the executor process are sharing the same underlying physical memory. It should be done by allocating large chunks of memory and distributing it to reduce memory allocation overheads and inter process communication.

cllvmc+++3
Student: Anubhab Ghosh
Code
Proposal

Extending Clang API Notes for C++: Overload-Specific Annotations for Ordinary Methods

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

This project extends Clang API Notes to support overload-specific annotations for C++ member functions. Today, API Notes cannot distinguish between overloaded methods such as foo(int) and foo(double), so annotations are applied to all overloads with the same name rather than to a specific function. The project introduces overload-aware matching for C++ methods, allowing API Notes to target individual overloads based on their parameter types while preserving compatibility with existing notes. This enables more precise annotations and improves interoperability for real-world C++ APIs, such as Swift bindings. The core deliverable is a working and tested implementation for explicit-parameter overloads (Phase 1), including typed-vs-legacy handling and regression tests. The project then extends this to support const- and ref-qualified member functions (Phase 2), completing support for receiver-sensitive overloads.

cllvmc+++3
Student: Dominic Stöcker
Code

Improved Loop Execution Modeling in Clang Static Analyzer

beginner
LLVM Compiler Infrastructure•2017Varies90h (Small)

<p>The current implementation of modeling a loop is quite simple in the Clang Static Analyzer. This simple approach results a loss of coverage, which indicates false negatives. There is already an implemented loop widening method in the Clang Static Analyzer.[1] However, it comes at the price that (almost) all of the MemRegions values will be invalidated. Hence, the false positive rate is relatively high in these paths. That is the reason it is not turned on by default but hidden behind a flag. My project would aim to improve the simulation of the loops in general. Moreover, it would provide an extensible and incremental way of loop widening in which only the relevant regions are invalidated, and thus can be turned on by default.</p> <p>[1] <a href="https://reviews.llvm.org/D12358" target="_blank">https://reviews.llvm.org/D12358</a></p>

cllvmc+++3
Student: Péter Szécsi
Code
Proposal

Learning Loop Transformation Heuristics

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>In this project we will look at loop transformation heuristics, such as the unroll factor.</p>

cllvmc+++3
Student: Ali Sedaghati
Code
Proposal

Write JITLink support for new format/architecture

intermediate
LLVM Compiler Infrastructure•2022Varies175h (Medium)

JITLink is LLVM’s new JIT linker designed to support a variety of new features, which includes full static initializer, thread local storage, and small code model, that were not possible in RuntimeDyld, the old JIT linker API. JITLink’s generic linker algorithm needs to be specialized to support the target object format (COFF, ELF, MachO), and architecture (arm, arm64, i386, x86-64). This project aims to implement the JITLink specialization for ELF/aarch64 and COFF/x86-64.

cllvmc+++3
Student: Sunho Kim
Code
Proposal

Incremental build support for the modules driver

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

Until recently, explicit module builds were only supported for Clang modules. With the -fmodules-driver mode upstream patch being merged, the community can finally experience explicit builds for both Clang modules discovered through module map files and C++ named modules. However, one of the main advantages of modules is their ability to being cached. Currently, -fmodules-driver does not support this. Therefore, the proposal strives towards an effort to bring forth an efficient, correct and safe filesystem cache. The proposed filesystem cache will enforce strong concurrency control. Once this cache system is fully implemented, the community will be able to use and manage it with existing Clang flags along with -fmodules-driver mode.

cllvmc+++3
Student: Aadarsh Keshri
Code
Proposal

Improve inter-procedural analyses and optimizations

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>In this project we aim to improve the deduction capabilities of the Attributor framework.</p>

cllvmc+++3
Student: Kuter Dinel
Code
Proposal

ClangIR upstreaming

advanced
LLVM Compiler Infrastructure•2025Varies350h (Large)

ClangIR is a new, MLIR-based intermediate representation of C and C++ code. It has been developed in an LLVM incubator project, but work is now underway to migrate the code from the incubator to the main LLVM repository. The goal for this project is to upstream the VectorType, ComplexType and Exception handling

cllvmc+++3
Student: Amr Hesham Gaber
Code
Proposal

Making Smart Pointer Checkers default checkers in the Static Analyzer

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>The Clang Static Analyzer currently has checkers for <code>std::unique_ptr</code>. These checkers are currently in the experimental (alpha) group of checkers. I intend to complete the <code>unique_ptr</code> checker so that it can be included in the default list of checkers and be enabled by default. In addition, I would like to add a checker for <code>std::shared_ptr</code> and <code>std::weak_ptr</code>, which would be an alpha checker.</p>

cllvmc+++3
Student: Deep Majumder
Code
Proposal
Showing 289 - 312 of 3883 Projects
1112131415
Proposal
Proposal
Proposal
Proposal
Proposal