Discover open-source organizations actively accepting contributors across GSoC, ESoC, LFX Mentorship, Outreachy, and more.
Carvel
Chaos Mesh
Cilium
Cloud-Native O-RAN
Code Gen
Carvel
Chaos Mesh
Cilium
Cloud-Native O-RAN
Code Gen
Carvel
Chaos Mesh
Cilium
Cloud-Native O-RAN
Code GenShowing 121–240 of 511 organizations
Browse projects
Cloud Native Computing Foundation (CNCF)
While generating Package Repository kctrl to create the tar version of the Package Repository instead of pushing the OCI Image to a registry. - Expected Outcome: - Proposal containing design discussions and options considered.

Cloud Native Computing Foundation (CNCF)
Description: Chaos Mesh is not like Chaos Engineering as a Service now: - Poor observability: the result of chaos experiments are not easy to observe and judge, the users need to check whether the Chaos effects by manual. - Chaosd(for physic node) is too simple: only supports command line operation, does not support task scheduling and life cycle management. - The costs of learning operation and maintenance are high: the maintenance of Chaos Mesh and Chaosd are not unified. - It should be a unified place to manage Chaos experiments for multiple platforms and multiple clusters, and can see the monitoring data of the experiment.

Cloud Native Computing Foundation (CNCF)
To be able to improve the Security posture of the Cilium family’s open source projects (Cilium, Hubble, Tetragon), we would need to create signed SBOMs, signed release artifacts for each open source project and automate all of these steps. https://github.com/cilium/cilium/issues/19282 https://github.com/cilium/cilium/issues/20712 https://github.com/cilium/cilium/issues/20850
Cloud Native Computing Foundation (CNCF)
Pack is the reference implementation of a Cloud Native Buildpacks platform used to build application images in multiple organizations. Because all developers want their code to build and deploy as quickly as possible, small speedups in pack can have significant benefits, and slow-downs in pack are undesirable. Today, pack has no benchmark suite that would safe-guard against regressions in execution speed. Expected Outcome: The mentee will create a benchmark suite around some critical path sections identified with help from maintainers. The mentee will be supported in applying profiling tools to identify possible speedups, hopefully leading to at least one user-facing performance improvement.
Linux Foundation
Help us fight climate change through nature-based solutions! The Full Lands INtegration Tool (FLINT) is a platform for estimating greenhouse gas emissions at local, national and global scales. This project aims to build a cloud deployment framework for rapid deployment of FLINT implementations. This framework will be used in a continuous deployment pipeline (CD) for integration testing and the delivery of FLINT as a service (FLINTcloud) for demonstration purposes. We hope to offer an easy entry point for new users to evaluate the FLINT platform and provide a blueprint for new users to roll their own FLINTcloud deployments. This is critical to help drive the adoption of FLINT and help scale up the monitoring, reporting and validation of carbon emissions and sequestration from land use and land use change around the world. This will involve: 1. Publishing a design for the complete FLINTcloud solution, detailing the required components, technologies and endpoints to be exposed. 2. Exposing the core FLINT routines by wrapping the existing command line interface in a REST API. 3. Creating a simple script to install the prerequisite libraries, FLINT and its modules as a standalone microservice. 4. Creating the deployment framework and setting up a CD pipeline on commodity cloud hardware, favouring automation wherever possible (e.g. infrastructure-as-code). 5. Providing new documentation for the cloud deployment procedure.

Linux Foundation
5G/6G wireless networks based on O-RAN architecture will have O-RAN Network Functions (NFs) deployed on the O-cloud infrastructure. The cloud infrastructure and the NF orchestration is managed by the SMO using the O-RAN O2 interface. Open-source projects such as O-RAN SC, ONAP, Nephio, OAI are actively engaged in developing open-source software for O-RAN networks, in alignment with guidance from the O-RAN Open-Source Focus Group. Building on the progress of open-source implementation of O-RAN NFs, the open-source community is now focusing on implementation of cloud-native O-RAN NF (e.g., O-CU, O-DU) as well as the SMO functionality to manage them via the O2 interface. There is an opportunity to set up an implementation in a university testbed to participate in the open-source projects, and enable research in cloud-native O-RAN (e.g., methods of monitoring the energy consumption of the cloud infrastructure and the NFs) In this project the student will leverage open-source code and - implement an example O-cloud infrastructure hosting one or more O-RAN NF(s) (e.g. O-CU, O-DU) at Rutgers University WINLAB (https://winlab.rutgers.edu/) - develop a setup and tutorial to enable multiple users to replicate the cloud-native open-source implementation and contribute to open source - study and develop open-source software to support management/data collection of the infrastructure and NFs from the SMO, using energy consumption as an example
Cloud Native Computing Foundation (CNCF)
This project aims to extend the CloudNativePG operator to support declarative configuration of foreign data wrappers through its Database custom resource. PostgreSQL supports the SQL/MED (Management of External Data) specification, enabling access to external data sources through standard SQL queries. These sources—known as foreign data—are accessed via foreign data wrappers (FDWs), which are libraries that handle the connection and data exchange with the external systems. A variety of FDWs are available for PostgreSQL. Of particular interest for this project is the postgres_fdw extension, which facilitates access to other PostgreSQL instances. Expected Outcome: 1) A detailed design discussion documented in the upstream issue in CloudNativePG GitHub repository, involving mentors, maintainers, and the community. 2) A fully working pull request implementing support for declarative foreign data wrappers, complete with: a. Reconciliation logic for the Database resource controller b. Documentation c. Automated tests integrated into the CI/CD pipeline
Linux Foundation
Mentoring program will cover NHN Cloud plugin development, including coding best practices, integration with Cloudforet, and troubleshooting. Participants will have the opportunity to work on real-world plugin projects, receive constructive feedback, and collaborate with experienced developers within the Cloudforet community.
Linux Foundation
Mentoring program will cover Naver plugin development, including coding best practices, integration with Cloudforet, and troubleshooting. Participants will have the opportunity to work on real-world plugin projects, receive constructive feedback, and collaborate with experienced developers within the Cloudforet community.
Linux Foundation
Mentoring program will cover various aspects of plugin development, including coding best practices, integration with Cloudforet, and troubleshooting. Participants will have the opportunity to work on real-world plugin projects, receive constructive feedback, and collaborate with experienced developers within the Cloudforet community.
Linux Foundation
Coccinelle is a tool for program matching and transformation. It was developed for the C language. Now we are creating a new version of Coccinelle for Rust. Rust brings new challenges, because it is an expression-oriented language, but also new opportunities, due to the existence of robust off-the-shelf tools for parsing and pretty printing.

Linux Foundation
The RISC-V movement has massive potential to unify a fragmented industry behind a single instruction set architecture (ISA). If technology providers 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 numerous projects which directly serve as the base components of the software ecosystem, including assemblers, disassemblers, compilers, linkers, loaders, simulators, emulators. In most of those projects today, the human-readable documentation is consulted, and the necessary implementations are performed manually. Needless to say, these processes are time-consuming, inefficient, and error-prone. A new foundation which can serve as a base for automatically generating large swaths of the processor-dependent ecosystem is available, but is not yet effectively use. The “RISC-V Unified Database” project has transformed the salient content from within the RISC-V specifications into an accessible format, YAML, from which content for downstream projects can easily and automatically be further transformed into the content necessary to their project which is currently produced by manual effort.
Linux Foundation
Codeuino is a volunteer-driven, open-source, social networking software development organization that desires the potential to change the way other communities and individuals use and create open-source social-environment tools to better align with end-user expectations, giving prospectus to various other organizations, users and activists to use the social environments built within Codeuino in a custom way. Donut is an open-source, feature-rich, highly flexible and privacy-friendly, social networking platform built for community-oriented collaboration in a customized way. It has been built on the Node.js framework allowing an essential impetus to provide custom and friendly rich widgets and an expansive library of modules to make communication and collaboration easy and successful. With a powerful module system, you can customize this platform by using third party tools, writing your own, or integrating other software.

Linux Foundation
The award-winning SERV (https://github.com/olofk/serv) is the world's smallest RISC-V CPU and is suitable for deeply embedded applications where chip area is at a premium. In a real system however, not only the CPU sets the system size and the smaller the CPU, the more important to also minimize the memory size. Adding support for the C ISA extension (compressed instructions) to SERV would enable RISC-V to reach even more use-cases on the deeply embedded side. SERV is an open source bit-serial RISC-V implementation written in Verilog with an emphasis on resource efficiency. The addition of the C ISA extension is expected to consist of changes to the instructions fetcher, an extra optional decoder stage for converting the compressed instructions into their non-compressed equivalents as well as other changes related to the PC not necessarily being word-aligned. On the infrastructure side, the relevant test suites (riscv-formal and riscv-compliance) are expected to pass and it should run the Zephyr operation OS with compressed instructions enabled. The SERV FuseSoC core description file should also be updated to allow users to conditionally select the C ISA extension at compile-time for simulation and FPGA/ASIC targets.

Linux Foundation
As organizations from different sectors move their computing workloads across multiple environments, from on-premises to public Cloud to Edge, they require greater assurances that their sensitive code and data are protected. Confidential Computing protects data in use by performing computation in a hardware-based Trusted Execution Environment (TEE). To learn more about the Confidential Computing Fellowship, please check the guide below: https://enarx.dev/docs/Fellowship/Introduction Also, please join the #mentorship chat channel at: https://chat.enarx.dev/channel/mentorship

Linux Foundation
This project focuses on contributing to mldsa-native, a work-in-progress implementation of the ML-DSA post-quantum signature standard. The mentee will help advance mldsa-native towards its first stable release by working on various aspects of building a secure, fast, and portable implementation. Tasks may include implementing constant-time analysis tooling, expanding test coverage, improving build systems, enhancing documentation, developing benchmarking infrastructure, or contributing to CI/CD pipelines. The project offers flexibility to focus on areas matching the mentee's interests while contributing meaningfully to this post-quantum cryptography implementation and helping achieve production readiness.

Cloud Native Computing Foundation (CNCF)
Copacetic currently doesn't support vulnerability scan reports by Wiz scanning. This mentorship project will extend Copa's support to cover this new scanning schema using a pre-existing template. Expected Outcome: The mentee will produce the following i. Design doc for Wiz Scanning ii. Wiz Plugin Integration iii. End to End integration tests

Cloud Native Computing Foundation (CNCF)
CoreDNS (https://github.com/coredns/coredns) is a cloud-native DNS server with a focus on service discovery. While best known as the default DNS server for Kubernetes, CoreDNS is capable of handle many other scenarios within or outside of Kubernetes clusters to make easy infrastructure management. One such case is certificate management. This project is to provide ACME protocol support so that it is possible to have automatic certificate management through CoreDNS. More details and discussions are available in https://github.com/coredns/coredns/issues/3460.

Cloud Native Computing Foundation (CNCF)
Description: Cortex Ruler queries ingester directly for rule evaluation. This is okay but if Cortex Ruler could query Query Frontend instead for rule evaluation, it can benefit from more features in the Query Frontend like vertical sharding. This also simplifies the Cortex ruler to not embed a querier and uses less resources. For this project, we would like to switch Cortex Ruler to query Query Frontend. You are expected to work with a microservice architecture and write unit tests and end to end tests to make sure the feature works correctly. Expected Outcome: Cortex Ruler talks to Query Frontend for rules evaluation.
RISC-V
Performance research/design of RISC-V CPU designs require workloads for analysis. Workloads can be custom user applications or industry benchmarks such as SPEC, GeekBench, Dhrystone, etc. Using tools like the RVI Olympia Perf CPU Model users can pinpoint bottlenecks in CPU design, the workload, or the compilers/libraries. When the workload is small, running the workload on Olympia is not complex: trace the workload using a functional model and run that trace through Olympia; count cycles. However, if the workload is large, tracing the entire workload is not practical. Workload reduction tools, such as SimPoint, help narrow down the points of interest (POI) as well as reduce the instruction length to calculate estimated performance. The flow using SimPoint: Workload -> SimPoint analysis (using tools like QEMU) -> workload fragments -> trace generation. Each trace can be run in parallel on Olympia to gather the point performance. Post-processing tools will collate the fragments and generate an overall estimate of performance. This internship will: * Establish workloads (research) * Establish a SimPoint flow to reduce the workloads (QEMU or other instruction set simulators) * Generate STF traces using SimPoint data (QEMU or other instruction set simulators) * Create a repository of traces and their metadata, such as compiler info * Tools to run traces on Olympia and generate perf data (python, C++)
Cloud Native Computing Foundation (CNCF)
Crossplane supports pulling packages from private registries through a variety of mechanisms, including IRSA, Workload Identity, and packagePullSecrets. There are a wide variety of environments in which a user is pulling a private package, which can lead to confusion about which to use, the precedence with which each is invoked, etc. This can lead to issues such as crossplane/crossplane#2876, where I suspect that we are resolving to Application Default Credentials, when we actually want to be using the provided packagePullSecret.
RISC-V
We want to discuss, map out, and plan a Next Generation Arithmetic (to include complex numbers) extension or equivalent to the RISC-V spec. This was discussed on the tech list a couple of years ago. We think there is a strong demand for this facility right now. The results of this work, likely including a feasibility study and code snippets, will inform the community on how to integrate NGA formats, including posits, into a RISC-V implementation. This internship will include our Journal Club approach where all interns will get opportunities to incorporate their additions and review the appropriate papers. To further these goals, and to give a reference to the substantial performance, accuracy and reproducibility advantages of NGA-enhanced RISC-V, a large number of CPU-based codes will be refactored to take advantages of the best parts of the appropriate arithmetic approaches while keeping floating-point options open.

Cloud Native Computing Foundation (CNCF)
Devfiles are YAML files that define remote development environments. The main part of a Devfile is the `components` section and that's where the containers required to code, build and test an application are specified. The Devfile can either include those containers defintions or reference external files such as Dockerfiles or Kubernetes manifests. [The Compose file](https://github.com/compose-spec/compose-spec/blob/master/spec.md) is a popular format in open source development projects to define runtime environments for testing the application but those cannot be referenced by a Devfile yet. The goal is to continue the work that has been started a couple of months ago to allow referencing a Compose file from a Devfile. The expected outcome is to create a PoC written in go that parses a Compose file such as [this one](https://github.com/microservices-demo/microservices-demo/blob/master/deploy/docker-compose/docker-compose.yml) using [kompose](https://github.com/kubernetes/kompose) (as a library, not as an executable) and that creates the objects corresponding to the Compose file services in a Kubernetes cluster.

Linux Foundation
Update FDC3-electron to support FDC3 2.0 Certify FDC3-electron on FDC3 1.2 and 2.0 Release fdc3-electron into mainstream repositories (NPM) Include 3+ samples in fdc3-electron as default Point fdc3-electron to FINOS global directory if existing Work with FDC3 maintainers to “approve” fdc3-electron as reference implementation and link into fdc3.finos.org

Linux Foundation
*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 Alpine was primarily designed by Google to enable testing of an SDN-controlled fabric without an embedded control plane. However, Alpine can be extended to support traditional routing protocols that are supported by hardware SONiC switches. This project will help make Alpine more broadly useful as a virtual SONiC switch. Expected Outcomes: 1: Enable the routing container (FRR) in Alpine virtual switch image 2: Extend the Alpine configuration to include BGP configuration 3: Test the configuration in a mirror testbed 4: Identify any data plane gaps (and if found, update Lucius) 5: Run the SONiC test suites 6: Document running and configuring BGP in Alpine Recommended Skills: Kubernetes, Linux, Networking, Go Relationship to SONiC and Impact on Community: One of the main goals of Alpine is to provide a virtual switch with a dataplane to accelerate software delivery with fast test iterations. Integrating support for the widely-used BGP protocol in Alpine significantly broadens its applicability and increases its relevance to the SONiC community. Additional Information: https://youtu.be/55X1_2utiVg
Linux Foundation
Increasingly, edge locations are becoming Kubernetes (K8s) based as K8s can support multiple deployment types (Virtual Network Functions, Containerized Network Functions, Virtual Machines and containers). ONAP4K8s is the project that enables ONAP to deploy workloads in K8s based sites. ONAP4K8s enables operators to use a K8s based sites to deploy workloads. In ONAP they can use this to deploy workloads on both Openstack based sites as well K8s based. It also enables usage of common compute resources for both network functions and applications, thereby utilizing compute infrastructure efficiently. ONAP4K8s is being extended to support deploying and connecting apps/services that span across multiple clusters. Major work items where intern can help are – 1. API enhancements 2. Improve code coverage 3. Adding support for application upgrades 4. Adding test cases for new use cases 5. Improving monitoring, tracing, logging of microservices

RISC-V
RISC-V Performance Modeling SIG is driving the development of Performance Modeling and Simulation Tools for use across RISCV membership to foster collaboration across the community. To that end, the SIG has developed a trace-driven performance model of an example RISC-V superscalar processor using C++ based on the Sparta simulation framework. The performance model, named Olympia, has been adopted by multiple organizations in both industry and academia. We have identified set of features for further development of Olympia: * Add support for execution-driven modeling - https://github.com/riscv-software-src/riscv-perf-model/issues/14 * Model state of art branch predictors along with decoupled frontend using branch-prediction API, with an example being the BOOM processor frontend documented at https://docs.boom-core.org/en/latest/sections/branch-prediction/index.html - https://github.com/riscv-software-src/riscv-perf-model/issues/143 - https://github.com/riscv-software-src/riscv-perf-model/issues/1 * Develop an API for Interconnect model and implement an example Interconnect microarchitecture. - https://github.com/riscv-software-src/riscv-perf-model/issues/60 * Use the API for data/instruction prefetcher and implement an example prefetcher microarchitecture - https://github.com/riscv-software-src/riscv-perf-model/issues/142 * Enhance the existing vector extension implementation Etc.

Linux Foundation
This project aims to improve the detection of timing side-channel vulnerabilities in the liboqs library by extending and integrating constant-time analysis tools into the CI pipeline. Past vulnerabilities such as Kyberslash, clangover highlight the need for improved automated detection. The mentee will explore existing tooling, enhance it for broader coverage, integrate it into liboqs workflows, triage and investigate any findings. The project may also include reporting issues upstream, contributing fixes, and documenting the results.

Linux Foundation
*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 To profile, analyze, and optimize Redis access patterns in SONiC's critical services and daemons, with the goal of reducing unnecessary Redis traffic and ensuring responsiveness even under load. Implement robust exception handling for Redis to prevent daemon crashes. Probable Implementation: Review GET/SET operations to ensure appropriate exception handling is in place. Use tools like redis-cli MONITOR, strace, perf, syslogs to identify: High-frequency Redis accesses Redundant or repeated GET/SET patterns Long response-time operations Focus on critical daemons like chassisd, pcied, lldp, syncd, orchagent. Apply the following optimizing methods for best performance: Use "HGETALL" instead of multiple "HGET" operations. Check for value-change before writing. Batching and use pipelining where it is missing. Benchmarking: Setup baseline Redis load tests and focus on couple of high CPU/mem consuming HWSkus Compare before/after metrics Redis command frequency Memory and CPU usage Expected Outcome: - High-level document outlining of existing Redis baseline, improvements required, etc. - Optimized Redis access operations - Improved exception handling for Redis reads/writes

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. The land sector is particularly important because there are not only emissions but also to potential for removals of greenhouse gases from the atmosphere. The Full Lands INtegration Tool (FLINT) is a platform for estimating greenhouse gas emissions and removals from land. This project: Develops new modules that represent the impacts of environmental changes on growth and mortality rates. Data from South Korea is used as a pilot. Scientifically, the key challenge is to translate information about tree-level responses to environmental changes to stand-level responses. Develops online training in response to COVID-19 to replace classroom training. A coherent approach to online instruction needs to be designed and the existing materials need to be turned into online ready versions.

Linux Foundation
Envoy is an open source edge and service proxy, designed for cloud-native applications.
Cloud Native Computing Foundation (CNCF)
Envoy Gateway translates Kubernetes-native Gateway API resources into xDS configuration consumed by Envoy Proxy. It also manages the lifecycle of the Envoy Proxy fleet by generating Kubernetes resources such as Deployments and Services. Currently, upgrades to Envoy Gateway (the control plane) result in immediate, in-place updates to the associated Envoy Proxy fleet (the data plane). While this operation is designed to be zero-downtime, some users prefer a staged upgrade process where the control plane is updated first, followed by a progressive rollout of the data plane. This project aims to design and implement support for progressive data plane upgrades, allowing users to decouple the control and data plane upgrade processes. This would provide enhanced control and safer rollout strategies (e.g., canary or blue-green deployments). Expected Outcome: 1. Design a two-step upgrade workflow that separates control plane and data plane updates. 2. Implement configuration or CRD support to control rollout strategy of the Envoy Proxy fleet. 3. Add documentation and example manifests for users to adopt the new workflow.
Linux Foundation
PCI and PCIe devices may support a number of possible reset mechanisms, for example Function Level Reset (FLR) provided via Advanced Feature or PCIe capabilities, Power Management reset, bus reset, or device specific reset. Currently the PCI subsystem creates a policy prioritizing these reset methods which provides neither visibility nor control to userspace. This project would work to expose the reset methods available per device to userspace, likely via sysfs, and allow a administrative user or device owner to have some ability to manage per device reset method priorities or exclusions. This feature aims to allow greater control of a device for use cases as device assignment, where specific device or platform issues may interact poorly with a given reset method, and for which device specific quirks have not been developed.
FINOS
Theme Builder is a React-based web application that allows users to create design systems that are accessible out of the box. Currently, users are not able to modify their design system's color palette or default color theme once it has been defined, because such changes may invalidate other design system updates that the user may have already made. This project is to modify the application to allow the user to make palette and theme changes in an existing design system and to add code to help users identify and correct issues that may arise due to the changes.

FINOS
FINOS (FinTech Open Source Foundation - part of the Linux Foundation) is looking for a summer marketing intern to assist with: - Marketing research (members, projects, BD) - Social media (research, operations) - Content for website (research, operations) - Podcast production (research, operations)
Linux Foundation
Introduction RISCV-ISAC: RISC-V ISAC is an ISA coverage extraction tool. Given a set of cover points and an execution trace of a test/application run on a model, ISAC can provide a report indicating in detail which of those cover points were covered by the test/application. ISAC also holds the capability to provide a detailed quality analysis on data propagation occurring within the test/application.RISCV-CTG is the RISC-V based Compatibility Test Generator. This tool is used to generate tests used in the official RISC-V Architectural Test Suite and the RISC-V architectural test framework RISCOF. All tests generated by the CTG are compliant with the official Test Format Spec. The CTG is similar to a constrained test generator capable of generating tests targeting a specific set of constraints. These constraints are supplied to the CTG using the Coverage Group Format (CGF) File. The CGF file contains various cover-points for different instructions. The CTG treats each cover-point as a constraint and employs a solver to identify potential solutions. CTG uses the constraint satisfaction problem (CSPs) solvers offered by the python-constraint package.

Linux Foundation
ISAC & CTG are essential components of the RISC-V Architectural Testing(AT) ecosystem. CTG generates tests for AT using the coverpoints as stimulus to ensure that complete coverage can be achieved with minimal testing. ISAC measures the coverage of the tests and reports on the quality of the test suite. This mentorship involves adding multiple features to both these tools to improve the quality of the architectural test suite. For further information on the tasks to be done during your internship refer here - https://gist.github.com/pawks/e2dec6d67224a9f68bf96fc909398c45 As part of the selection process, all candidates are required to successfully complete the coding challenge described here before August 3rd : https://gist.github.com/pawks/98863e5eca71c8b80b18e060cb4d9558

Linux Foundation
Fluentd is an open source data collector for building the unified logging layer. Once installed on a server, it runs in the background to collect, parse, transform, analyze and store various types of data.

Cloud Native Computing Foundation (CNCF)
Flux has several integration points with hyper-scaler platforms e.g., AWS. In general it is tricky to test these satisfactorily, because it requires running in the platform and thereby incurring usage costs. GCP donate credits that are used to test there; and now the Flux project has been generously granted credits to use for testing in AWS, and we can create conformance tests for AWS specifically too. Expected outcome: A suite of conformance tests for AWS integrations in Flux.

Hyperledger
As conceptualized and standardized by the W3C, the Verifiable Credentials protocol is one of the three pillars of Self-Sovereign Identity, together with the Decentralized Identifiers protocol (DIDs) and Distributed Ledger Technology (or Blockchain). The project aims to design and build a verifiable credential registry (VCR) on GitHub repository, namely GitHub-based Verifiable Credential Registry (GVCR), by leveraging existing GitHub APIs, and other open-source tools provided by other Hyperledger projects, such as Aries, Indy, and Ursa. The basic architecture is already built. For more details about the conceptional design and workflows, please refer to the GitHub repository GitHub-VCR.
Linux Foundation
Assist in development of the initial GenevaERS demo system, including building views, test processes, procedures to allow initial users to download and use GenevaERS successfully.
Linux Foundation
Help us fight climate change through nature-based solutions! The Full Lands INtegration Tool (FLINT) is a platform for estimating greenhouse gas emissions at local, national and global scales. This project aims to improve moja global's documentation by building a community website and adopting consistent standards across our projects.
Linux Foundation
GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

Cloud Native Computing Foundation (CNCF)
Description: Design, plan and implement an and UI and backend to be able to visualize per project and/or for the registry vulnerability overview which will allow better security audits and vulenrability mitigation Expected Outcome: Addition to the Web UI which can be used to represent in full for the whole Harbor instance or per project the vulnerability status of the images, which will allow Harbor admin or project admin to get an overview of the existing vulnerabilities on in the images, also to provide capability to export the data via the CVE exporter so it can be consumed in 3rd party tools(not necessary to be complete functionality) Upstream Issues: https://github.com/goharbor/harbor/issues/16680 https://github.com/goharbor/harbor/issues/10496 https://dso.docker.com/explore?search=pkgs
RISC-V
This project aims to ease the transition and implementation of Posits, an alternative numerical representation, for RISC-V systems. By creating a robust hardware abstraction layer (HAL), developers need not know if the target RISC-V platform has a hardware Posits implementation or requires a software implementation. This new POSIX-compliant C++ library (with ports planned eventually) will help make available the option to transition between IEEE Float / Doubles to Posits and should make the machine-specific selection and configuration seamless. The lack of such a HAL is a roadblock in Posit adoption and Posits represent a serious opportunity for free and open source silicon (FOSSi) systems. Initial focus will be directed toward HPC support, where numerical computation efficiency may be best observed. Additionally, we will be conducting benchmarking studies to evaluate the performance of the HAL, identifying bottlenecks, and iterating on the design based on empirical data. The testing framework will also be part of the mentee's deliverables.
RISC-V
This project aims to ease the transition and implementation of Posits, an alternative numerical representation, for RISC-V systems. By creating a robust hardware abstraction layer (HAL), developers need not know if the target RISC-V platform has a hardware Posits implementation or requires a software implementation. This new POSIX-compliant C++ library (with ports planned eventually) will help make available the option to transition between IEEE Float / Doubles to Posits and should make the machine-specific selection and configuration seamless. The lack of such a HAL is a roadblock in Posit adoption and Posits represent a serious opportunity for free and open source silicon (FOSSi) systems. We will also update the existing posit implementations to the current standard and add consistent unit testing. Initial focus will be directed toward HPC support, where numerical computation efficiency may be best observed. Additionally, we will be conducting benchmarking studies to evaluate the performance of the HAL, identifying bottlenecks, and iterating on the design based on empirical data. The testing framework will also be part of the mentee's deliverables.

Linux Foundation
The healthcare system in Pakistan, particularly in rural areas, faces significant challenges due to limited access to medical facilities and high costs of conventional diagnostic equipment. These constraints leave a large portion of the population underserved, with limited access to timely and reliable healthcare. This project aims to address these gaps by providing a low-cost, portable healthcare solution powered by energy-efficient Edge-AI. By leveraging advancements in RISC-V technology, the proposed solution can revolutionize healthcare delivery in underprivileged areas, ensuring affordable and accessible diagnostics for all. The project, Healthcare-Centric Edge-AI Development on RVMCU Architecture, builds upon the RVMCU, a RISC-V microcontroller designed during the Linux Foundation's Spring 2024 LFX Mentorship Program. The RVMCU, which is compliant with the RV32IMC_Zba_Zbb_Zicsr_Zifencei specifications, was developed as an ultra-low-power, versatile SoC. This proposal seeks to extend that foundational work to enable healthcare-centric applications, specifically targeting wearable and portable devices. The enhanced RVMCU architecture will support diverse healthcare sensors (e.g., cough monitors, heartbeat detectors, ECG sensors) and provide real-time AI-powered analytics. The emphasis will be on achieving energy efficiency, modularity in hardware and firmware design, and seamless integration with AI frameworks optimized for edge computing.

Linux Foundation
Hyperledger Labs Blockchain Automation Framework(BAF) is a tool to deploy different DLT platforms automatically on a given Kubernetes cluster. BAF supports multi-cloud and multi-DLT deployments, and already supports HL Fabric, HL Besu, Quorum, R3 Corda. For HL Besu, currently only IBFT2 Consensus is supported by BAF. With this internship program we want to support the Clique consensus for Besu, so that BAF can be used to deploy and operate a HL Besu network with Clique consensus. This will also include upgrading BAF to support the latest stable Besu version. The mentee will be able to learn: 1) Production grade architecture. 2) evOps in Blockchain Development. 3) Architecture of Besu and BAF. 4) work in true spirit of open-source, communicating with both Besu and BAF community, joining calls and using other community tools. 5) writing documentation, so anyone in the community could use the results of their work. 6) following rules and standards of open-source projects created by Hyperledger. Expected Outcome 1) Documented, ready-to-use Besu Clique consensus on BAF. 2) Documented upgrade of Besu to latest stable on BAF.
Hyperledger
Hyperledger Fabric is a prominent blockchain framework known for its enterprise-grade features and modular architecture. Within Hyperledger Fabric, chaincode (smart contracts) plays a crucial role in defining transaction logic and business rules. Ensuring the correctness and security of chaincode implementations is essential for the reliability and trustworthiness of Hyperledger Fabric networks. This research proposal aims to explore formal verification techniques specifically tailored for verifying the correctness and security properties of Hyperledger Fabric chaincode.
Hyperledger
In Hyperledger Fabric, there can be a significant mismatch between the simple key-value ledger storage abstraction and the data representation style used for developing chaincode – i.e., Java has classes and objects, not keys and values. Currently, there aren’t really good tools for facilitating the “object-key-value mapping” (at least anything approaching classic Object-Relational Mapping – ORM). This not only complicates chaincode development, but a less than systematic approach with the mapping can lead to performance problems (through logically unnecessary MVCC conflict transaction invalidations). Additionally, an explicit object-oriented ledger data model would enable imposing data-centric constraints on the ledger content, either for runtime checking or development time verification and validation. The goal of the mentorship is to design and implement an object-key-value mapper with the following functionality: - Generating key-value storage models from UML ledger data models - Application of storage strategies during the mapping (as we explored in the report referenced below) - Generating a chaincode-internal Java data access/persistence layer, “parameterized” by the storage model - Demonstration on a representative example (e.g., our earlier work on faithfully implementing TPC-C to Fabric) - (If we have time): declaring OCL (Object Constraint Language) constraints on the models and enforcing them in the data access layer
Hyperledger
The Hash Time Locked Contract (HTLC) is a well-known pattern for dis-intermediated asset swaps, i.e., as a mechanism to exchange assets between two parties in two different blockchain networks in an atomic manner without a trusted mediator (or trusted third party). HTLC support has been implemented in the Hyperledger Weaver Labs project, with mechanisms to lock, claim, and unlock assets supported in both the contract and higher application layers. At present, the protocol requires several manual steps by the application users carrying out the exchange or agents acting on their behalf. We would like to automate this process as much as possible by augmenting the relay module in Weaver to communicate events and trigger transactions in foreign networks; this requires both research and software development. Further, HTLC is known to have flaws that could violate system integrity properties, because it relies on parties to execute certain actions by a certain timeout or forever lose the opportunity to carry out those actions; this makes the basic protocol intolerant to system crashes. Research is needed to (provably) determine the best way to make the HTLC protocol fault tolerant, using the features of the blockchain networks maintaining the assets and the Weaver relays mediating the exchange. Augmenting the existing HTLC mechanism within Weaver will provide practical validation of this research.
Hyperledger
The utility emissions channel is a Hyperledger Fabric application which calculates Greenhouse Gas (GHG) emissions from utility bills and stores them on a Fabric ledger. This can then be used to generate audited emissions for businesses and individuals and help them calculate and offset their total carbon footprint. Because the application involves looking up data and performing numerical calculations, it's important to have automated tests to make sure that it's done correctly. As part of this project, you will develop automated tests for the utility emissions channel which will validate that the application is working as expected. These tests will verify that the application is looking up the utility bills for the correct customer and time frame, using the correct emissions factors data to calculate GHG emissions, recording them correctly on the Fabric ledger, and finally tokenizing them correctly on an Ethereum network. There are currently tests written to submit requests via REST API which connects to the chain code. The tests could be enhanced and eventually packaged along with deployment scripts so that a fresh testing instance could load all the data and run all the scripts to validate the results. Expected Outcome At the end of the project, you will have had a lot of fun, helped with climate change, and created an automated test suite to validate the utility emissions channel's emissions calculations.
Hyperledger
The objective of this project is to improve the interoperability of different blockchain networks by developing smart contract gateways that can interact with multiple networks. These gateways will automate, trace, and secure the process of submitting transactions to other blockchain networks. To achieve this goal, the project will involve creating smart contract gateways for various blockchain networks, including those using the same platform, as well as gateways to submit transactions to heterogeneous networks. The initial focus will be on developing gateway smart contracts for connecting multiple separate Hyperledger Fabric networks, and the next step will be to create gateways to connect Hyperledger Fabric to other heterogeneous networks, such as Hyperledger Indy and Besu. The project's primary objective is to evaluate system-level and large-scale integrations, which will be accomplished by setting up an extensive network of blockchains using Hyperledger Fabric as the source blockchain and other networks as destination networks. Overall, the project aims to enhance the efficiency, security, and traceability of cross-blockchain transaction submissions, thereby improving the overall functionality of blockchain technology.
Hyperledger
Cross-chain bridges are a vital part of the blockchain landscape as they enable data and value to move seamlessly across different blockchains. Security is of utmost importance in this area, as these bridges can be vulnerable to malicious attacks and manipulation. In addition to securing bridges, measuring their performance and scalability is key to understanding if one is meeting the highest standards and is capable of encountering users' needs. This is mandatory to achieve mass adoption of the technology by single users and businesses. There have been some efforts to design and implement interoperability solutions across different blockchains, some of which are within the Hyperledger ecosystem (see links in the next section). Furthermore, preliminary research has been conducted to benchmark interoperability solutions, however, we feel there is currently a lack of studies that thoroughly compare bridges – used both within and between Hyperledger and public blockchains used in the industry. We aim to address this gap and conduct such evaluation studies, mainly through benchmarking. The goal of this project is to benchmark cross-chain solutions, an essential step for measuring the performance of any solution. As the adoption of cross-chain bridges grows it is increasingly important to have benchmarks to measure cross-chain solutions' performance and security.
Hyperledger
The Carbon Accounting and Certification Working Group is developing an Operating System for Climate Action, where data from a Hyperledger Fabric channel is tokenized on an Ethereum network. We would like to create a more robust integration with Hyperledger Cactus. Learning Objectives As part of this project, you will learn about 1) Hyperledger Fabric chain code development 2) Hyperledger Cactus cross-chain integration 3) REST APIs 4) Ethereum and Solidity 5) Open source development and project management Expected Outcome Implementation of an integration from Hyperledger Fabric utility emissions data channel to issue tokens on an Ethereum network using Hyperledger Cactus. Documentation and tutorials showing how the integration is done.
Hyperledger
Now most users can easily deploy a blockchain network. On this basis, they need to manage the blockchain more flexibly and safely. Hyperledger cello will implement a fully decentralized BaaS. Each organization can independently deploy and manage its own baas, including their own private keys. Among organizations that have deployed cello, blockchain networks can be flexibly established. Through learning and development work, complete the design and development of some interfaces and front-end pages of the platform
Hyperledger
Cacti enables two blockchain or DLT networks to transfer digital assets between each other using different mechanisms and modules, inherited from the older Cactus and Weaver projects. The Node Server acts as a container for business logic to orchestrate (or trigger) transactions across multiple networks toward achieving some desired simultaneous state change in those networks. The Relay acts as a gateway, or an ingress/egress appliance, for a given network to send communication to, and receive communication from, another network. Using the Relay or the Node Server or both, one can effect a digital asset transfer from one network to another, sample protocols for which have already been implemented in Cacti with samples for demonstration. Parallelly, there is an ongoing effort to standardize blockchain/DLT interoperation protocols through consultation and brainstorming among experts within the field under the IETF's aegis. The goal of this project is to implement the more current SATP draft specification in Cacti, in the process augmenting the Cacti Relay to be a gateway that provides a reference or template for any other standardized implementation. Using other Cacti modules and sample apps, secure transfers of digital assets using SATP must also be demonstrated. If time permits, performance measurements may also be conducted to benchmark the protocol, and specifically the Relay.
Hyperledger
Cacti provides a protocol and trigger mechanism for the sharing of ledger data or data derived from smart contracts (called "view", and identified by a "view address") deployed in a network with another network using relays for communication and consensus-driven proof generation and verification in the end networks. Some parts of the protocol are generic and DLT-agnostic but others, specifically protocol drivers or connectors and core ledger operators (typically built as smart contracts) are DLT-specific. Presently, Cacti provides DLT-specific data sharing mechanisms for Hyperldger Fabric and Corda. The goal of this project is to add similar support, i.e., build modules, plugins, and API for permissioned networks built on Hyperledger Besu. As an optional extension, these mechanisms will then be extrapolated to share data to and from public Ethereum. This will involve designing and basic building blocks or capabilities for view proof generation, proof verification, and access control of remote data requests, in the form of smart contracts. Higher up the stack, the Cacti SDK for Besu must then be augmented to enable network apps to trigger data sharing requests and submitting the responses for validation to local smart contracts.
Hyperledger
Creation of polkadot connector plugin, alongside its cactus-polkadot-all-in-one docker image (hosting a sample polkadot ledger for testing purposes) and the test-tooling package for the AIO Learning Objectives - Hyperledger Cacti codebase - Hyperledger Cacti connector design - Understanding of various interoperability solutions, design and usage of cactus api server - Expected Outcome - Creation of polkadot connector - Creation of polkadot all in one docker image - Creation of polkadot test tooling classes - Documentation, architecture reference diagrams for the polkadot connector
Hyperledger
Hyperledger Cactus is a blockchain decentralised integration tool designed to allow users to securely integrate different blockchains started by companies Fujitsu and Accenture. Cactus has pluggable architecture which makes easy to integrate various blockchain by creating plugin, currently plugins for Fabric, Besu, Quorum are implemented. Cactus allows to transfer not only assets but also data between multiple blockchains. Hedera Hashgraph is a DLT built on top of an asynchronous BFT algorithm, providing smart contract, token, and consensus services to end users. The flexibility - Document ready-to-use integration of Hedera and Cactu, - Document example of integration using Hedera's Testnet and Hedera's Previewnet - Document example of integration between another blockchain and Hedera using Cactus
Hyperledger
Develop a Cactus Chia connector plugin + test infrastructure (container images, container manager class, etc.) from scratch. Include end to end test cases powered by Jest and the said testing infrastructure that prove that the connector is working as intended with a locally simulated Chia network. You will be creating a new package in the Cactus monorepo from scratch under the packages/cactus-plugin-ledger-connector-chia/ path. All the information presented here can also be found at the GitHub issue tracker of Hyperledger Cactus, filed under issue #1634 => github.com/hyperledger/cactus/issues/1634
Hyperledger
Develop a connector that provides both synchronous and asynchronous modes of interacting with a running Hyperledger Besu node. The connector would act as an interface between an enterprise application and the Hyperledger Besu node for data ingestions and it could provide event subscription options. The scope of the project would also include an end-to-end test on a sample network.
Hyperledger
The emergence of blockchain interoperability is reducing the risk of investing in blockchain by avoiding vendor lock-in, leveraging interoperation with off-chain systems, and providing a truly open ecosystem, enabling a network of blockchains. In particular, in the technical report we wrote, we designed a survey aimed to understand the socio-technical challenges that blockchain interoperability poses, with the goal of offering a unique opportunity to link the underlying technology with human experience and values. We discovered that end-users are particularly concerned with visualizing and analyzing cross-chain cost and throughput, with some indication that measuring energetic expenditure in the cross-chain setting would also be valuable. Following that survey, we implemented a simple PoC that obtains transaction receipts from different blockchains and aggregates them in a unified repository. This project aims to build on top of what was done and create a cross-chain model (taking into account what end-users what to analyze from such model) automatically from input cross-chain transactions. This project will take a cross-chain use case, create a model and allow end-users to extract relevant metrics, promoting a better understatement of the business logic running on blockchain infrastructures, and of interoperability.
Hyperledger
The project DRman has an end goal of developing a stand-alone utility to provision Verifiable Credential Registries [VCR]. The utility can also be used to administer the registry containing credentials issued by the organizations. The functionalities like creation, verification, modification, and revocation of credentials, form the core of this project as it enables the administrator to manage the VCR with ease. The significant aspects to be considered here are Creation, Onboarding (Enable/Restrict Access) of members, and Management(add/update/revoke) of DIDs. a) Creation (of DID Registry): Function to create a DID Registry for an organization on Git. The automation is already done for this part and can be tracked at https://github.com/DIDman/DRman/issues/3. b) Onboarding: Function to add enable/restrict access to members of an organization to a repository (e.g., using a combination of GitHub private tokens, GitHub username & users DID). c) Manage: Function to list APIs that are needed to add/update/revoke access DID’s or (DID Document) saved as files on the repo. This summer, the project holds a variety of interesting automation issues to be addressed that focus more on onboarding and management of the organizations that intend to add themselves to the DID-based Verifiable credential registry.
Hyperledger
The goal of this project will be to build a template or sample Interoperation Identity Network (IIN) by minimally augmenting existing decentralized identity registries built on Hyperledger Indy and Aries, adding support for group Decentralized Identifiers (DIDs), and optionally proposing changes or additions to W3C standards for DIDs and Verifiable Credentials (VCs). To demonstrate the working of identity plane protocols, existing Cacti IIN agents for Hyperledger Fabric must be augmented, and IIN Agents for Corda must be built, enabling data sharing and asset transfer across networks built on either Fabric or Corda. Also, a sample trust anchor must be designed and implemented as a service to issue VCs to network members.
Hyperledger
Hyperledger Cactus support ledger Interoperability but use a local deployment for testing; Hyperledger Bevel supports production-worthy deployments. This project aims to support Cactus deployment using Bevel to demonstrate production-like usage of Hyperledger Cactus. The steps will be following: 1. Deploy a Hyperledger Fabric network using Bevel on a Managed Kubernetes cluster 2. Deploy a GoQuorum network using Bevel on a Managed Kubernetes cluster (can be the same cluster for simplicity). 3. Make changes in Hyperledger Bevel code to deploy the Cactus connectors in both the above networks. 4. Run Cactus test cases.
Hyperledger
The Hyperledger Labs blockchain-carbon-accounting project has progressed significantly, and we're looking to move to production deployment of it. The deployment of a Hyperledger Fabric, however, has been a difficult and time consuming process in the past. Working with the maintainers of Hyperledger Bevel, we would like to streamline the deployment processes for both Fabric and Besu networks. Our goal is to allow any organization to join the networks using its own cloud infrastructure. At the end of the project, we are looking for: - Successful deployment of blockchain-carbon-accounting across multiple cloud networks, such as Digital Ocean, AWS, and Azure. - Scripts for further maintenance of the networks. - Detailed tutorials and learning materials which would benefit both blockchain-carbon-accounting developers and the broader Fabric, Besu, and Bevel communities.
Hyperledger
This project is meant to serve as a proof-of-concept for implementing decentralized identity and payment rails in the gaming (and by extension a future metaverse) ecosystem. This project has the following distinctive goals: 1. Implement a mini game project as a proof-of-concept (POC) that demonstrates use of decentralized identity and payment systems using Hyperledger chains such as Indy & Aries for Identity and Firefly for digital assets. 2. Conduct research on existing methods used for identity and payments and how use of Hyperledger blockchains can provide utility functions in such ecosystems 3. Conduct research and coding on how this game project can implement digital wallets for storing credentials and digital assets using design principles and recommendations from the Open Wallet Foundation
Hyperledger
The Hyperledger Foundation is looking for a Developer Marketing mentee to support marketing efforts tied to our developer ecosystem. This mentee will work alongside the Hyperledger Foundation Marketing Manager in support of social media marketing, developer events and Hyperledger Global Forum our annual global conference in September and conduct research on which marketing activities can be leveraged to grow developer engagement. Responsibilities will include conducting market analysis, monitoring social platforms, and preparing promotional materials - Collaborate with the team to perform market analysis and research on the latest trends around developer engagement and marketing - Contribute to the content calendar with social media postings on a weekly basis - Monitor analytics with the rest of the team to identify viable ideas, trends, and growth patterns
Hyperledger
Hyperledger AnonCreds includes specifications and implementations of AnonCreds (Anonymous Credentials) Zero-Knowledge Proof (ZKP)-based verifiable credentials. AnonCreds extends the capabilities of “typical” verifiable credentials by including important privacy-preserving features including selective disclosure, ZKP predicates (e.g., proving I’m older than 21 based on my date of birth without sharing my date of birth), and not revealing any correlatable identifiers in presenting credentials. The version 1.0 specification (based on CL-Signatures as initially implemented in Hyperledger Indy) is near completion, and work has begun on the version 2.0 specification that will retain and extend the privacy-preserving features of AnonCreds v1.0, while improving capabilities, performance, extensibility, and security. An implementation based on the Version 2.0 specification will occur in parallel with the development of the specification. - For the Version 1.0 specification, the primary task will be to extract the cryptographic primitives from identified sources, confirm alignment with the Rust implementation of AnonCreds, and include the cryptographic primitives in the specification. This is the last step of the specification to make it ready for submission to a standards development organization (SDO). - The Version 2.0 specification, the task will be similar, but the work will extend he focus as appropriate to implementation of the cryptographic primitives.
Start with GSoC, European Summer of Code, Outreachy, or LFX — then drill into orgs.