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.

PlatformProgramsOrganizations

Explore Organizations

Discover open-source organizations actively accepting contributors across GSoC, ESoC, LFX Mentorship, Outreachy, and more.

RISC-V Engagement Apprenticeship logoRISC-V Engagement ApprenticeshipRISC-V as a First-Class Citizen in Kernel CI - Part II logoRISC-V as a First-Class Citizen in Kernel CI - Part IIRISC-V as a First-Class Citizen in KernelCI logoRISC-V as a First-Class Citizen in KernelCIRT-Smart Open Source Micro-kernel Operating System Running on RISCV64 Platform logoRT-Smart Open Source Micro-kernel Operating System Running on RISCV64 PlatformRacklet logoRackletRandom Test Generation for RISC-V Vector Extension logoRandom Test Generation for RISC-V Vector ExtensionRefactoring and Enhancing the RISC-V Opcodes Repository logoRefactoring and Enhancing the RISC-V Opcodes RepositoryRepository Service for TUF (RSTUF) logoRepository Service for TUF (RSTUF)Ruby Tools Developer logoRuby Tools DeveloperSAIL to CGEN logoSAIL to CGENSODA API logoSODA APISPDX Online Tools logoSPDX Online ToolsRISC-V Engagement Apprenticeship logoRISC-V Engagement ApprenticeshipRISC-V as a First-Class Citizen in Kernel CI - Part II logoRISC-V as a First-Class Citizen in Kernel CI - Part IIRISC-V as a First-Class Citizen in KernelCI logoRISC-V as a First-Class Citizen in KernelCIRT-Smart Open Source Micro-kernel Operating System Running on RISCV64 Platform logoRT-Smart Open Source Micro-kernel Operating System Running on RISCV64 PlatformRacklet logoRackletRandom Test Generation for RISC-V Vector Extension logoRandom Test Generation for RISC-V Vector ExtensionRefactoring and Enhancing the RISC-V Opcodes Repository logoRefactoring and Enhancing the RISC-V Opcodes RepositoryRepository Service for TUF (RSTUF) logoRepository Service for TUF (RSTUF)Ruby Tools Developer logoRuby Tools DeveloperSAIL to CGEN logoSAIL to CGENSODA API logoSODA APISPDX Online Tools logoSPDX Online ToolsRISC-V Engagement Apprenticeship logoRISC-V Engagement ApprenticeshipRISC-V as a First-Class Citizen in Kernel CI - Part II logoRISC-V as a First-Class Citizen in Kernel CI - Part IIRISC-V as a First-Class Citizen in KernelCI logoRISC-V as a First-Class Citizen in KernelCIRT-Smart Open Source Micro-kernel Operating System Running on RISCV64 Platform logoRT-Smart Open Source Micro-kernel Operating System Running on RISCV64 PlatformRacklet logoRackletRandom Test Generation for RISC-V Vector Extension logoRandom Test Generation for RISC-V Vector ExtensionRefactoring and Enhancing the RISC-V Opcodes Repository logoRefactoring and Enhancing the RISC-V Opcodes RepositoryRepository Service for TUF (RSTUF) logoRepository Service for TUF (RSTUF)Ruby Tools Developer logoRuby Tools DeveloperSAIL to CGEN logoSAIL to CGENSODA API logoSODA APISPDX Online Tools logoSPDX Online Tools

Showing 1,201–1,257 of 1,257 organizations

Browse projects
RISC-V Engagement Apprenticeship logo

RISC-V Engagement Apprenticeship

RISC-V

Unlock your creative potential and make a global impact! RISC-V International invites you to join our vibrant, international community and play a pivotal role in boosting our online presence. RISC-V International is looking for an individual willing to help the community and technical program managers in a variety of tasks. A good candidate will be an independent self starter who can assist with graphic design, program management and video editing. Got a flair for podcasts or started one yourself? That's a fantastic bonus! See what its like to work in different departments of a Open Standard Project. Don't miss this extraordinary opportunity to grow your skills and make a difference with this 30 hour a week, remote role. Apply now!

project managementvideo editingpodcast experience+3
1 active years
Explore
RISC-V as a First-Class Citizen in Kernel CI - Part II logo

RISC-V as a First-Class Citizen in Kernel CI - Part II

RISC-V

This mentorship project aims to elevate RISC-V to a first-class architecture within the KernelCI project, aligning its support and testing capabilities with those of more established architectures. KernelCI is a community-driven, open-source testing infrastructure focused on ensuring the quality and long-term stability of the Linux kernel. This project will focus on bridging gaps in RISC-V integration, creating a replicable CI pipeline, and enabling consistent, comprehensive testing for RISC-V in KernelCI.

ci/cdcloud computinglinux+6
1 active years
Explore
RISC-V as a First-Class Citizen in KernelCI logo

RISC-V as a First-Class Citizen in KernelCI

RISC-V

This mentorship project aims to elevate RISC-V to a first-class architecture within the KernelCI project, aligning its support and testing capabilities with those of more established architectures. KernelCI is a community-driven, open-source testing infrastructure focused on ensuring the quality and long-term stability of the Linux kernel. This project will focus on bridging gaps in RISC-V integration, creating a replicable CI pipeline, and enabling consistent, comprehensive testing for RISC-V in KernelCI.

ci/cd pipeline managementcloud computing and apislinux+15
1 active years
Explore
RT-Smart Open Source Micro-kernel Operating System Running on RISCV64 Platform logo

RT-Smart Open Source Micro-kernel Operating System Running on RISCV64 Platform

Linux Foundation

(1) Port RT-Smart open source micro-kernel operating system to Allwinner D1 development board(RISC-V Architecture), deepen the study of RISCV64 processor architecture, boot process and debugging approaches. (2) Research on device driver development, component development, system device framework development, software component development, protocol stack, file system, device tree and some others. (3) GUI Application: port open source LVGL, create a practical product based solution, with network, file system, GUI display, Internet of Things applications. (4) Put this project into mass production.

willing to experience new technologies and love to explore and learn something new.continuous learning capacity as it is the ongoing expansion of knowledge and skill sets.aware of putting the learning knowledge into the practice and chase for more possibilities.+3
1 active years
Explore
Racklet logo

Racklet

Cloud Native Computing Foundation (CNCF)

The future is already here - it's just not evenly distributed” - William Gibson We’d like to introduce an idea for a new open-source project: Racklet. It’s a fully-integrated, Raspberry Pi form-factor server rack and software stack that aims to be a scale model of hyperscaler datacenters. All layers of the stack are 100% OSS/OSH, and will be developed together with the community. It’s reproducible through open PCB designs, 3D printed casing, and commodity, off-the-shelf hardware. We want to lower the barrier of entry for becoming cloud native. Racklet aims to inspire users to explore how modern server architectures work, in a tangible and educational way. Emphasis is put on security, knowledge sharing, extensibility, and portability. The goal is to conceptually map to real environments and provide an accessible and well-documented path to welcome future talents to the world of cloud native.

gorustkubernetes+2
1 active years
Explore
Random Test Generation for RISC-V Vector Extension logo

Random Test Generation for RISC-V Vector Extension

RISC-V

"Following the ratification of RVV specification, the software simulation framework and RTL designs for RVV have been released. Given the complexity of RVV design and the combinations of its configuration, both developers and users need a golden test suite to verify the correctness of the respective RVV implementations and simulations. RIOS lab thus introduces this project and contributes to RISC-V foundation. In this project, you will be designing a RVV test generator to help verify the functionality of either simulator or ASIC design of RISC-V vector processors. This project has two phases. In the first phase, we will write the a constant test suite generator for RVV that automatically produces the same test streams given a fixed RVV configuration. This would help debug and ensure reproducibility needed by developers. While in phase 2, we will extend the test generator to produce random vector test to cover the corner case of the RVV design. RVV Spec: https://github.com/riscv/riscv-v-spec RISC-V CTG: https://github.com/riscv-software-src/riscv-ctg RISCOF: https://github.com/riscv-software-src/riscof RISCOF Documentation: https://riscof.readthedocs.io/en/latest/intro.html Learning Objectives: 1. RVV instruction set architecture 2. How does vector processor work? 3. Formal Verification of RVV 4. Test generation and verification model 5. Design of advanced random test generation framework

risc-vpythonrisc-v assembly+1
1 active years
Explore
Refactoring and Enhancing the RISC-V Opcodes Repository logo

Refactoring and Enhancing the RISC-V Opcodes Repository

RISC-V

The RISC-V opcodes repository is a critical resource in the RISC-V ecosystem, containing opcode definitions and metadata that are essential for various tools and projects. However, the repository's current state has developed some complexities and inconsistencies over time, making it difficult to maintain and expand. This mentorship project aims to refactor and enhance the repository, improving its structure, maintainability, and overall usability. The mentee will start by conducting a comprehensive audit of the repository, identifying redundant and inconsistent elements. Following this, the repository will be systematically refactored to align with modern software engineering practices. This includes modularizing the codebase, enhancing documentation, and reorganizing metadata for better clarity and accessibility.

gitpythonyaml+2
1 active years
Explore
Repository Service for TUF (RSTUF) logo

Repository Service for TUF (RSTUF)

Linux Foundation

The purpose of this project is to enhance the (Repository Service for TUF RSTUF) implementation by tackling critical areas that would significantly improve its functionality, scalability, and ease of adoption. RSTUF is designed to manage content distribution efficiently using the TUF (The Update Framework), but it currently has areas where improvements in delegation flexibility, performance, testing, and documentation are needed. This project will allow RSTUF to handle larger and more complex scenarios, while providing an improved experience for both developers and adopters. Goal - Enable succinct hash-bin delegations within custom delegations: Enhance the flexibility of RSTUF’s delegation model to allow for more fine-grained delegation control. - Improve performance on the online role bumping process: Optimize the process of updating large numbers of delegated roles to improve scalability, especially in environments where there are many roles to manage. - Enhance the developer experience by improving functional tests: Improve the effectiveness, reusability, and performance of the functional tests that ensure RSTUF’s features work across releases. - Improve documentation to facilitate easier adoption: Enhance the user-facing documentation to make it clearer, more comprehensive, and more accessible for new adopters, thus accelerating the onboarding process.

documentation best practicesuser-focused documentationtest-driven development (tdd)+19
1 active years
Explore
Ruby Tools Developer logo

Ruby Tools Developer

Linux Foundation

Many UDB tools are written in Ruby, including documentation generators and an instruction set simulator (ISS) generator. This mentorship involves developing and maintaining these tools. Proficiency in Ruby is required, while experience with Asciidoc or C++ is preferred but optional. Knowledge of compiler concepts like Abstract Syntax Trees is a plus.

good communication skillscomputer architectureverification
1 active years
Explore
SAIL to CGEN logo

SAIL to CGEN

Linux Foundation

SAIL-RISC-V golden model is currently being actively developed and focuses on the ISS export feature whereby a reference interpreter/emulator is automatically generated from the specification. Prior work on RGEN has shown that export the LLVM (as well as QEMU and PyTorch) is possible, to support automatic flow of custom instruction extensions (modules) to compiler intrinsics, emulators and AI frameworks. In this project, the export feature shall be extended to cover CGEN, the compiler ISA definition/extension framework for GCC. Building on initial work done at Embecosm earlier, we will upgrade the CGEN framework, build transformations to automatically generate CGEN descriptions given a SAIL specification using an example of tensor/matrix multiply extension.

unix development environment (make, cmake, c, scripting)knowledge of scheme (or lisp, or any functional language)unix development environment (make+5
1 active years
Explore
SODA API logo

SODA API

Linux Foundation

SODA API is an open source implementation of SODA API Standards for Data and Storage Management. The effort is to provide a common unified data and storage interface to store, run any data anywhere. This project implements the API Server, Different API services, utilities and more. The implementation will be based on the API standards from The SODA Foundation. It connects the application or client to the storage backends to do data/storage management seamlessly providing a platform and storage agnostic framework. Any application or client platform can implement the interface using the API specification to connect to API or implement northbound plugins to bridge their specifications to SODA API. Currently we support block and file APIs for key features of data management (provisioning, migration, fileshare, etc). for on-prem implementation This is one of the SODA Core Projects and is maintained by SODA Foundation directly. Provides the standardization for Data / Storage Management APIs. Currently we support block and file APIs for key features of data management (provisioning, migration, fileshare, etc). Working to add the storage management APIs. This is the key external interface to platforms, which can do a seamless integration with heterogeneous storage backends.

gokubernetesdocker+2
2 active years
Explore
SPDX Online Tools logo

SPDX Online Tools

Linux Foundation

The Software Package Data Exchange (SPDX) is an open source standard for communicating software bills of material information (including components, licenses, copyrights and security references). To support SPDX, an online tool has been developed which provides an easy all-in-one website to upload and parse SPDX documents for validation, comparison and conversion and search SPDX license list. This project will provide enhancements and support for the online tools including: - More automated and high-quality deployment for software updates - Removing some of the dependencies on a Python Java Bridge by moving features like license matching over to a native Python implementation - Improving performance and quality of the online tools implementation

djangopython
1 active years
Explore
SPIFFE/SPIRE logo

SPIFFE/SPIRE

Cloud Native Computing Foundation (CNCF)

SPIRE (https://spiffe.io), the SPIFFE Runtime Environment, is an extensible system that implements the principles embodied in the SPIFFE standards. SPIRE manages the platform and workload attestation provides an API for controlling attestation policies and coordinates certificate issuance and rotation. Being a critical system, it is important that operators be able to monitor (and respond to) the current health/state of their SPIRE deployments. To do this, SPIRE needs to grow a full-featured health subsystem that is capable of collecting the status of other subsystems and reporting on it. In this project, you will design and implement this new subsystem with the help and guidance of the SPIRE maintainers.

go
1 active years
Explore
Sailing Downstream logo

Sailing Downstream

Linux Foundation

Background: Current flows from RISC-V Sail specification to downstream implementations have manual steps which are time-consuming and can introduce errors.A lack of familiarity with Sail and OCaml presents a barrier to adoption of Sail as the basis for automated downstream implementations: emulators, simulators, compilers, assemblers, disassemblers, instruction stream tools, documentation, etc. Proposal: - Create an accessible Sail backend. - Extract salient information. - Transform it into an accessible database (JSON). - Survey projects dependent on RISC-V ISA for how that dependency is realized. - Utilize JSON to directly and automatically generate downstream source that is currently generated by hand. - Create a React-based interactive RISC-V ISA reference by directly importing the JSON database. Benefits: The backend can serve as a model for creation of additional Sail backends. The JSON database itself may be sufficient for many downstream uses. Creating downstream source shows feasibility, and a process for a fully-automated downstream flow. Additional collaboration with the effort to transform Sail into documentation is warranted. Much of the effort to transform Sail into JSON is complete, but there is still significant effort ahead: - enhanced parsing - enhancing the RISC-V Sail specification itself with more required content Much of the effort in creating an interactive web site is complete, but there is work to support the incorporation, display, and filtering.

pythonjavascript (or similar)web development+6
1 active years
Explore
Sailing Downstream II logo

Sailing Downstream II

Linux Foundation

This ongoing “Sailing Downstream” project strives to transform the salient content from within the RISC-V Sail specification into a more accessible format, JSON, that downstream projects can easily and automatically transform into the content necessary to their project which is currently produced by manual effort. Project efforts and components span: - Adding to the RISC-V Sail specification information necessary for the various downstream projects. - Improving the RISC-V Sail specification so that the salient information can be easily identified and extracted. - Enhancing an existing Sail “JSON backend” to extract salient information completely and accurately and produce that information in a usable JSON format. As the end goal is to enable automatic adoption of changes, enhancements, and new content of the RISC-V ISA into downstream projects, efforts can be made to provide example implementations of such transformations to inform engagement with select downstream projects for adopting new automated processes.

gitgithublinux/bash+7
1 active years
Explore
Sailing Downstream III logo

Sailing Downstream III

Linux Foundation

The RISC-V movement has massive potential to unify a fragmented industry behind a single instruction set architecture (ISA). If the participants in the industry can agree to focus their efforts on a single processor architecture, rather than duplicating efforts among incompatible architectures, the entire computing ecosystem benefits. Inefficiency in critical base components of the ecosystem hampers this consolidation. There are separate efforts in documenting the RISC-V ISA, succinctly describing the semantics of the ISA in the RISC-V Sail implementation, and the numerous projects which directly serve as the base components of the software ecosystem, including assemblers, disassemblers, compilers, linkers, loaders, simulators, emulators. In summary, the tasks in this project will include: Improving the RISC-V Sail specification. (Sail language, git/GitHub) Improving the Sail parser’s JSON backend to extract more complete and accurate information. (OCaml, git/GitHub) Improving the RISC-V ISA interactive web site with new functionality and information. (Javascript, React, Carbon, or similar web frameworks, git/GitHub) Survey downstream projects which have dependencies on the RISC-V ISA. (C, C++, RISC-V assembly) Implement transformations of RISC-V ISA representation in JSON into downstream project content. (Python or similar, C, C++, RISC-V assembly) Engage with upstream projects (Sail, RISC-V Sail specification) to submit change proposals and see that they become acceptable.

gitgithub apilinux+10
1 active years
Explore
Sample Project logo

Sample Project

Cloud Native Computing Foundation (CNCF)

Sample

html
1 active years
Explore
Service Mesh Interface logo

Service Mesh Interface

Linux Foundation

A standard interface for service meshes on Kubernetes.

goreactgithub actions+2
3 active years
Explore
Service Mesh Performance logo

Service Mesh Performance

Cloud Native Computing Foundation (CNCF)

The adaptive load controller is to execute optimization routines recursivley to determine the maximum load a system can sustain. The maximum load is usually defined by the maximum requests per second (rps) the system can handle. The metrics (CPU usage, latency etc) collected from the system under test are the constraints we provide to judge whether a system under test (SUT) is sustaining the load. A use-case that fits very well is be the ability to use it to run performance tests on a schedule and track the maximum load a system can handle over time. This could give insights to performance improvements or degradations.

analyticsalgorithmdata science+14
4 active years
Explore
Slack to Zowe integration logo

Slack to Zowe integration

Linux Foundation

Allow a user to create a slack channel to their mainframe and ask questions, e.g. "Is my job finished" or "Is task ABCD still running", ... Slack communicates using Zowe CLI commands and a text to command language parser creates the calls, e.g. Watson AI assistant

rest api
1 active years
Explore
Software Discovery Tool - Add z/OS support logo

Software Discovery Tool - Add z/OS support

Linux Foundation

Develop back and front end support for z/OS in the Flask framework (Python), and work with the team to create the initial JSON source file for open source z/OS software

z/ospythonflask+1
1 active years
Explore
Specification Encoder logo

Specification Encoder

Linux Foundation

A goal of UDB is to encode the existing RISC-V specification into a machine-readable and referenceable format. This involves interpreting the existing prose to classify statements as mandatory, optional, informative, and/or conditional (for example, on the presence of an extension). This mentorship opportunity would benefit individuals interested in technical documentation or learning parts of RISC-V in depth. It will likely involve working with subject-matter experts to understand the intent of ratified specifications.

good communication skillscomputer architectureverification
1 active years
Explore
Strimzi logo

Strimzi

Cloud Native Computing Foundation (CNCF)

A really common use case we have been seeing is about enabling an IoT scenario with MQTT based devices and using an Apache Kafka cluster as the events and storage platform running on Kubernetes via Strimzi. In order to do that, there is the need to map the MQTT protocol to the custom Apache Kafka one and bridge from one to the other. This project idea is about designing such a mapping and developing a pure [Netty](https://github.com/netty/netty/tree/4.1/codec-mqtt/src/main/java/io/netty/handler/codec/mqtt) based MQTT server component (not a full MQTT broker) able to accept MQTT client connections and handling the corresponding communication based on the [MQTT 3.1.1 specification](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html). Finally, developing the Kafka producer part to get messages from MQTT clients and sending them to an Apache Kafka cluster. - Expected outcome: POC source code for an MQTT to Apache Kafka bridge

kafkajavamqtt
1 active years
Explore
Supervisor Domains Priv. ISA Extension Emulation logo

Supervisor Domains Priv. ISA Extension Emulation

Linux Foundation

Security-sensitive workloads on embedded and server platforms require isolation primitives to support many use cases that require enforcement of confidentiality and integrity for workload against software and hardware adversaries. Providing these protection properties requires architectural support for page-based physical memory isolation managed at the machine level to be able to create isolated supervisor domains which can then host isolated S/H and (V)U, V(S) mode software. A supervisor domain can extend the trusted computing base (TCB) to host isolated VMs and/or applications. The Supervisor domains task group has defined privileged ISA extensions (Smsdid, Smmtt, Smsdia, Smsedbg etc.), to be used by machine mode to isolate physical memory, and other platform resources flexibly across supervisor domains. As specified in the RISC-V Supervisor Domains specification, per-hart controls for a supervisor domain identifier can be used to program a memory tracking table (MTT) structure that will specify if a supervisor domain is allowed to access physical memory regions (at architectural page-size granularities). The MTT will be programmed by an M-mode root-domain security manager (RDSM). The mentee will primarily focus on developing extensions to Qemu to emulate the RISC-V Supervisor Domain (Smmtt) ISA extensions, and build an priv. software prototype for the M-mode RDSM using OpenSBI to demonstrate the functionality of the emulated ISA.

programming in cc++rust preferred+3
1 active years
Explore
Swss VS test robustness logo

Swss VS test robustness

Linux Foundation

*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 Primary Focus: This mentorship program focuses on optimizing VS tests and thereby reducing the flakiness and improving the checker time. Problem statement: VS tests plays a crucial role in PR checkers and ensuring zero regressions. However, the current infra-structure can take up to 4hrs to run the VS test and for any single failure, the rerun costs time and manual efforts. This project idea is to make VS test more robust and convert top flaky VS tests to mock test. Internship Objectives: - Convert VS tests from pytest to mock/mock test - Run current PR checkers and with unit tests and measure the time. - Aim to reduce the PR checker time significantly and predictable results Expected Outcomes and Deliverables: - Reduce the time for PR checkers and get consistent results - Submit a pull request and upstream the code changes to the SONiC swss repo. Recommended Qualifications: Education: - Undergrad student. Skills & Interests: - Eager to contribute to the SONiC open-source community. - Have Linux, Python/C/C++ experience - Academic background in Computer Science, Computer Engineering, or a related field.

pythonc++linux
1 active years
Explore
Syscall Intercept for RISC-V logo

Syscall Intercept for RISC-V

RISC-V

Syscall Intercept libraries created for X86 systems, provide a way to safely intercept system calls exceeding the capabilities or library interception (LD_PRELOAD). However, the standard library provided was created by Intel for X86 systems. This library is a key piece for Adhoc-FS for example (DAOS, GekkoFS, and others). Community has done efforts to port it to ARM and PowerPC architectures, but we are missing the RISC-V. The proposal will be divided in several steps: 1- Practical hands-on with the library (2 Weeks) , 2 - Analysis of RISC-V instructions and OS to define an strategy for intercept syscalls (4 weeks) 3 - Coding RISC-V version of syscall intercept (4 weeks), 4 - Testing and creating the fork of syscall intercept for RISC-V (2 weeks).

kernellinux insightsc programming+2
1 active years
Explore
Syzkaller on FreeBSD/RISC-V logo

Syzkaller on FreeBSD/RISC-V

RISC-V

The goal of this project is to get syzkaller, a coverage-guided OS kernel fuzzer, working under FreeBSD/RISC-V. As syzkaller is written mostly in Go, the first step is to ensure that Go is able to compile syzkaller. Previous work can be harnessed from two projects to make this tractable. First, Go has a RISC-V port targeting GNU/Linux, and second, the CHERI project has a FreeBSD/mips port of Go. The next step is to add FreeBSD/RISC-V support to syzkaller itself. A work-in-progress patch for FreeBSD/arm64 support can be used as a template. Two bonus tasks are: 1. upstream Go support for FreeBSD/RISC-V to the Go Project, and 2. begin fuzzing system calls under FreeBSD/RISC-V. Syzkaller is flexible enough to target OS interfaces other than system calls. For example, it has been used to fuzz the Linux USB stack and has found dozens of bugs in the USB subsystem alone. The details are complicated, but the idea is simple. 1. Generate a program, which invokes one or more system calls. 2. Run the generated program. 3. Check to see if the system diagnosed an error. - If not, collect kernel code coverage information and decide whether to try iterating upon the previous test program, or start anew. - If so, collect information about the crash and try to discover a minimal test case that triggers the crash. The mentors will have weekly meetings with the mentee to discuss progress and strategies for overcoming any challenges.

experience with operating system internalsexperience with systems programmingsolid c programming experience+4
1 active years
Explore
TAG Contributor Strategy logo

TAG Contributor Strategy

Cloud Native Computing Foundation (CNCF)

pair.sharing.io is a mentoring / pair environment used by ii.nz that brings up clusters to co-learn and co-author via tmate+emacs and a live cluster with many features useful to cloud native development. However, while many folks find the ideas useful, it would be good to reach a wider audience by bringing up workspaces w/ VSCode as an alternative to emacs. The request is for a PoC deploying coder.com to CNCF Infrastructure (likely Packet) and bringing over some of the methods of collaboration learned by ii on pair to a wider audience.

shellterminalvs code+2
2 active years
Explore
TAG Network logo

TAG Network

Cloud Native Computing Foundation (CNCF)

The OpenAPI specifications for Kubernetes provides taxonomy, but augmenting a graph data model with formalized ontologies enables any number of capabilities, one of the more straightforward is the inferencing requisite for natural language processing, and consequently, a human-centric query / response interaction becomes becomes possible. More importantly, more advanced systems can be built when a graph data model of connected systems is upgraded to be a knowledge semantic graph. Expected Outcome: - YAML-formatted definition of one or more relationships per Kubernetes resource. - Documentation of each relationship - per component. - Development of new types of genealogies - new types of ways in which resources relate to one another and how these relationships might be visualized. - Verification of functional relationships

devopskuberneteswritten english+4
1 active years
Explore
TAG Network and Observability logo

TAG Network and Observability

Cloud Native Computing Foundation (CNCF)

Network topologies and graph databases go hand-in-hand. The OpenAPI specifications for Kubernetes provides taxonomy, but augmenting a graph data model with formalized ontologies enables any number of capabilities, one of the more straightforward is the inferencing requisite for natural language processing, and consequently, a human-centric query / response interaction becomes becomes possible. More importantly, more advanced systems can be built when a graph data model of connected systems is upgraded to be a knowledge semantic graph. Deliverables (among other items): - a Kubernetes ontology using OWL as a popular (and mature) way of doing this. - a cuelang-based component generator

cuelanggoneo4j
1 active years
Explore
TUF logo

TUF

Cloud Native Computing Foundation (CNCF)

Open source projects need help with their documentation! The TUF project is a good place to start. We'd welcome help from others to help here and become contributors to other projects / TAGs later in the project period. The mentee will (with minimal guidance from the CNCF team and TUF project) do a CNCF assessment (https://github.com/cncf/techdocs/blob/main/assessments/howto.md) for the TUF documentation. Expected Outcome: Both an improvement of project docs and the development of a new contributor. A mentee will understand how to do technical writing for an open source project.

front-end web developmentinformation visualizationtechnical writing+1
2 active years
Explore
TestGrid logo

TestGrid

Cloud Native Computing Foundation (CNCF)

Description: [TestGrid](http://testgrid.k8s.io) is the test visualization tool attached to Prow to collate and display historical test results for the k8s and k8s-adjacent Expected Outcome: Create Lit-based view components for TestGrid (summary, index, etc.) that display data from the API. Implement Jasmine and Storybook testing for these components.

typescriptcssgo
1 active years
Explore
Thanos logo

Thanos

Linux Foundation

Thanos is a set of components that can be composed into a highly available metric system with unlimited storage capacity, which can be added seamlessly on top of existing Prometheus deployments.

goyamlreact+19
6 active years
Explore
Thanos Compactor logo

Thanos Compactor

Cloud Native Computing Foundation (CNCF)

In the Thanos Compactor UI there is visibility of the global block list and loaded block list. But it would be useful to also have a list of planned and currently running compaction groups in order to see what exactly is in progress. This way it would be easier to diagnose what the Thanos Compactor is currently working on, and possibly what is delaying the progress of compactions. This is especially useful if you have large TSDB blocks in S3 buckets that take time to get compacted. Expected Outcome: We have an endpoint in Compactor that details compaction plan, and this is also visualized in a Compactor UI page.

goreactprometheus+1
1 active years
Explore
TiKV logo

TiKV

Cloud Native Computing Foundation (CNCF)

Build an integration test framework with Jepsen for TiKV, using the TiKV Rust client.

rustgodatabase+4
2 active years
Explore
Tremor logo

Tremor

Cloud Native Computing Foundation (CNCF)

Tremor supports a number of other systems to connect one, yet one of the most widespread API's in the cloud world (S3) isn't yet supported. This is a chance to shine and build something many users will enjoy.

rustprogramming language designtesting+20
2 active years
Explore
UETRV PicoCore logo

UETRV PicoCore

RISC-V

"Overview: The UETRV PicoCore project aims to enhance the capabilities of the existing UETRV_Pcore RISC-V core, making it a versatile and feature-rich open-source microcontroller. The core is RV32IMA Linux-compatible and Privilege Architecture 1.10 compliant, and we envision integrating essential extensions such as bitmanip, floating point, debug, trace, and GPIO peripherals. This initiative aligns with the broader goal of providing a comprehensive RISC-V MCU solution that is accessible to the open-source community. Tasks: Bitmanip Extension Integration: The Bitmanip extension offers advanced bitwise manipulation instructions. The task involves integrating this extension into the existing UETRV_Pcore, optimizing its usage, and ensuring compatibility with existing codebases. Floating Point Extension Integration: Incorporating the Floating Point extension will enable hardware-accelerated floating-point computations. This task involves integrating the extension into the core, optimizing performance, and ensuring compliance with the RISC-V standard. Debug, Trace, and GPIO Peripherals: Enhancing the microcontroller's capabilities, this task involves integrating debug and trace functionalities for improved development and debugging. Additionally, GPIO peripherals will be integrated to facilitate easy interfacing with external devices.

risc-v architecturefpgaplatformio+2
1 active years
Explore
Using Machine Learning to Predict Deforestation logo

Using Machine Learning to Predict Deforestation

Linux Foundation

Climate change is the biggest challenge of our time. We need all the help we can get to reduce emissions in every sector. Forest are particularly important as they can remove CO2 from the atmosphere. Moja global's software Full Lands INtegration Tool (FLINT) estimates greenhouse gas fluxes from land use. Progress means that emissions today are lower than the baseline, i.e. emissions we would have observed had we done nothing. A baseline requires predicting the rate of deforestation in case we had done nothing. So we need a formula linked to local proxies that predicts deforestation locally, but that can be aggregated to the level of a state, province or country without losing consistency. Proxies can be location of hamlets, roads, agriculture, recent deforestation, etc. Most approaches use social research and linear programming to develop an algorithm that predicts deforestation. This project proposes to develop the algorithm based on machine learning.

machine learningimage processingdeep learning+4
2 active years
Explore
Veraison logo

Veraison

Linux Foundation

Remote attestation verifier service and supporting libraries.

willingness to learnproblem solving mindsetprevious experience+7
1 active years
Explore
Verilator VPI array value accessor logo

Verilator VPI array value accessor

Linux Foundation

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.

hardware emulationprofessional developmentopen-source contributions+6
1 active years
Explore
Vitess logo

Vitess

Cloud Native Computing Foundation (CNCF)

Vitess is a cloud-native database, while managing Vitess can be complex, the list of our getting started guide and code examples is not very exhaustive. We would like to have a mentee work on growing the list of code examples and guide to help new users acquire Vitess. Given the mentee's fresh eyes, we would like them to contribute to the troubleshooting / common issues guide too. Expected Outcome: By the end of the term, the mentee will have a deeper knowledge of Vitess and shipped at least one guide in every area of Vitess.

goreactvite+22
5 active years
Explore
WasmEdge logo

WasmEdge

Cloud Native Computing Foundation (CNCF)

The [WasmEdge QuickJS runtime](https://wasmedge.org/book/en/dev/js.html) is a secure, fast, and lightweight JavaScript runtime for cloud-native applications. Compared with more established JavaScript runtimes like Nodejs and Deno, the WasmEdge QuickJS runtime provides runtime isolation and security at a very low overhead. In order for WasmEdge QuickJS to be more widely adopted, it needs to support [nodejs](https://wasmedge.org/book/en/dev/js/nodejs.html) applications. WasmEdge QuickJS already supports [NPM and CJS modules](https://wasmedge.org/book/en/dev/js/npm.html).

rustwebassembly rust sdkwebassembly+60
6 active years
Explore
Women in Energy Open Source Mentorship Programme (Unpaid) logo

Women in Energy Open Source Mentorship Programme (Unpaid)

Linux Foundation

<p>The Women in Energy Open Source Mentorship Programme is a first-of-its-kind initiative designed to bring more women into open source energy modelling. Developed in partnership between Open Energy Transition (OET), LF Energy, the World Resources Institute (WRI), EnergyHaus Africa and the Centre for Net Zero, the programme builds structured, supported pathways that connect aspiring women energy modellers with experienced practitioners across the ecosystem. The programme addresses a critical gap, women remain significantly underrepresented in open source energy modelling communities worldwide. This is not just an equity issue. It is a capability gap. When the people building energy models do not reflect the diversity of the communities those models serve, the models themselves are weaker for it.</p><p><br></p>

python
1 active years
Explore
Wrapping proprietary printer drivers into a Printer Application Support for IPP Fax Out. logo

Wrapping proprietary printer drivers into a Printer Application Support for IPP Fax Out.

Linux Foundation

With sandboxed packaging, Linux distributions appear which do not use classic RPM or DEB packages any more, like the all-Snap Ubuntu Core. As a result CUPS will not work with classic PPD/filter-based printer drivers any more but requires all drivers being provided as Printer Applications. The student's task is to add this functionality to the Printer Application framework and create an easy way for users to install proprietary printer drivers into that chroot-equipped Printer Application. IPP Fax out is a feature which is currently missing in Linux unlike Print and Scan. The student's task here is to make this functionality easily accessible for users of common desktop Linux distributions. Like printers, faxes should automatically appear on the system and get available in print dialogs and if one prints to a fax, fax-specific options should also appear in the print dialog and the user should be able to pick phone numbers also from contacts.

cc++python+2
1 active years
Explore
XDP redirect logo

XDP redirect

Linux Foundation

The eXpress Data Path (XDP) feature in the kernel enabled high performance programmable packet processing using BPF. This is achieved by way of the XDP hook for attaching BPF programs to a very early stage of packet processing in the network drivers. This allows very high packet processing performance, and XDP programs have access to the full packet data and can filter or steer packets using kernel helpers and different return codes. The XDP_REDIRECT return code is the most flexible of the return codes and is used to direct packets to other places in the system, including other network interfaces, other CPUs, or straight to userspace. While the redirect feature is conceptually simple from the BPF user's point of view, the implementation of it in the kernel uses various tricks to improve performance as packets traverse the different parts of the kernel. This project aims to improve various outstanding issues of the XDP redirect facility. The exact tasks taken on will be up to the mentee's particular interests and skill set, and can include implementing missing pieces of functionality, performance analysis and improvements as well as adding kernel selftests. We have a list of issues to tackle which includes things like: - Implementing missing redirect features for Generic XDP - Improving performance through bulking of operations on redirect - Adding selftests for redirect map types - Improving the usability of BPF samples using redirect

cgnu makeshell+2
1 active years
Explore
Yocto Project logo

Yocto Project

Linux Foundation

The Yocto Project (YP) is an open source collaboration project that helps developers create custom Linux-based systems regardless of the hardware architecture.

embedded & iot
1 active years
Explore
ZOROW - BYO z/OSMF Workflow logo

ZOROW - BYO z/OSMF Workflow

Linux Foundation

Develop z/OSMF workflow for some common tasks such as copying one dataset to other. Learn various capabilities provided by z/OSMF workflow. Contribute the z/OSMF workflows to the ZOROW community.

xml
1 active years
Explore
Zowe - Metrics Dashboard for ML services logo

Zowe - Metrics Dashboard for ML services

Linux Foundation

A single dashboard that clearly shows individual services as well as aggregate system information, for transport-level information like request rates, error rates, etc., and lower-level information like CPU usage. This dashboard should have interactions available to fine-tune what metrics are shown.

rest api
1 active years
Explore
Zowe Client Java SDK logo

Zowe Client Java SDK

Linux Foundation

Create SDK written for Java to interact with the Zowe

java
1 active years
Explore
Zowe Explorer extension templates logo

Zowe Explorer extension templates

Linux Foundation

The sample VS Code extension should satisfy a generic mainframe use case (search, compare, etc ) and be hosted on github.com/zowe. The extension should demonstrate how to call directly to a backend service and extend Zowe Explorer via a new tree or menu options.

json
1 active years
Explore
Zowe toolkit plugin for IntelliJ logo

Zowe toolkit plugin for IntelliJ

Linux Foundation

Here in we propose to develop a set of Zowe plugins for the IntelliJ family of development environments. This will ensure uniform user experience, while adding the possibility to work in their favorite development environment. The plugins will share a common foundation to interface with the IntelliJ platform SDK and to access the Zowe resources through Zowe API ML.

json
1 active years
Explore
gittuf logo

gittuf

Linux Foundation

gittuf is a security layer for Git repositories, allowing for a security policy to be applied independently of the service the repository may be hosted on (e.g. GitHub, Gitlab, Bitbucket, etc…). The purpose of this project is to improve gittuf in several domains, such as functionality, usability, and ease of access for new users. Goal - Build a tool to help with visualization of gittuf’s metadata: gittuf uses metadata inspired by The Update Framework (TUF). While there is functionality in gittuf to examine its metadata, a visualization tool would help with understanding how gittuf’s metadata is structured, especially for new users and complex policies. - Enable temporary/time-limited approvals: There may be cases when a developer may need to exercise some discretionary authority and approve something in violation of the policy (e.g. a critical security patch at 4am may not be able to be approved by the full team required in policy). Adding approvals that will satisfy the policy for some duration of time (but not infinitely) would serve to improve this aspect of gittuf.

documentation best practicesunit testsgit+6
1 active years
Explore
improving stress-ng kernel coverage logo

improving stress-ng kernel coverage

Linux Foundation

stress-ng is a tool designed to stress test and exercise core components of a kernel. This project aims to improve the test coverage of stress-ng using data driven test coverage data generated using gcov. The project will help increase understanding of the Linux kernel interfaces with userspace, usage of tools such as gcov and experience with C programming.

clinuxkernel+4
1 active years
Explore
in-toto logo

in-toto

Cloud Native Computing Foundation (CNCF)

Help contributors get started with improving the documentation of CNCF projects and TAGs. To start, we'd like mentees to help to improve both the documentation of a project, and also encourage them to contribute to other projects. So, view the issues as a starting point to help start your career in open source. Expected Outcome: Develop effective documentation for CNCF projects. As a start, the CNCF project in-toto has a fairly clear set of requirements for what documentation changes are needed.

gopythonjava+2
1 active years
Explore
kube-burner logo

kube-burner

Cloud Native Computing Foundation (CNCF)

We intend to get some help around open issues in the repository and also come up with new use cases and scenarios for performance testing any kubernetes distribution. We love new perspectives and are always open to new ideas alongside what we have as tracked work in github issues. Expected Outcome: The knock down some of open critical issues and bring in new perspective to the project.

golangkubernetescloud platforms
2 active years
Explore
mixcore logo

mixcore

Linux Foundation

Fully Open Source UI Tools to create web apps. n nCMS and Dashboards built on top of .Net Core, Angular.JS and Bootstrap. n nCreating your web from scratch with the dedicated experience development team can be very expensive. Using our solutions you don't have to worry about tech.

dotnet core cmsdotnet-corecms+8
1 active years
Explore
todogroup logo

todogroup

Linux Foundation

TODO is an open group of companies who want to collaborate on practices, tools, and other ways to run successful and effective open source projects and programs

documentation
1 active years
Explore
Page 11 of 11
7891011

Looking for a program first?

Start with GSoC, European Summer of Code, Outreachy, or LFX — then drill into orgs.

All programs