Discover open-source organizations actively accepting contributors across GSoC, ESoC, LFX Mentorship, Outreachy, and more.
TAG Network
TAG Network and Observability
TestGrid
Thanos
TiKV
Tremor
UETRV PicoCore
Using Machine Learning to Predict Deforestation
TAG Network
TAG Network and Observability
TestGrid
Thanos
TiKV
Tremor
UETRV PicoCore
Using Machine Learning to Predict Deforestation
TAG Network
TAG Network and Observability
TestGrid
Thanos
TiKV
Tremor
UETRV PicoCore
Using Machine Learning to Predict DeforestationShowing 481–511 of 511 organizations
Browse projectsRISC-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.
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.

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

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
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.

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.

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.
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.

Cloud Native Computing Foundation (CNCF)
Build an integration test framework with Jepsen for TiKV, using the TiKV Rust client.

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.

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.

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.

Linux Foundation
Remote attestation verifier service and supporting libraries.
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.

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.

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).
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>

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.
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
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.
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.
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.
Linux Foundation
Create SDK written for Java to interact with the Zowe
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.
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.

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.

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.
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.

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.
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.

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
Start with GSoC, European Summer of Code, Outreachy, or LFX — then drill into orgs.