Discover open-source organizations actively accepting contributors across GSoC, ESoC, LFX Mentorship, Outreachy, and more.
Compressed instructions for SERV
Confidential Computing Fellowship
Contributing to first stable release of mldsa-native
Copacetic
CoreDNS
Cortex
Devfile
Electron FDC3
Compressed instructions for SERV
Confidential Computing Fellowship
Contributing to first stable release of mldsa-native
Copacetic
CoreDNS
Cortex
Devfile
Electron FDC3
Compressed instructions for SERV
Confidential Computing Fellowship
Contributing to first stable release of mldsa-native
Copacetic
CoreDNS
Cortex
Devfile
Electron FDC3Showing 841–960 of 1,257 organizations
Browse projectsLinux 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.
Hyperledger
To establish consistent and comprehensive documentation standards for the Hyperledger Foundation open-source blockchain platforms. Our goal is to provide developers, users, and other stakeholders with high-quality technical documentation that is accurate, accessible, and easy to understand. Our end goal is to ensure that the technical documentation for the Hyperledger community is of the highest quality, making it easier for developers to build on these platforms and for users to understand and utilize them effectively. Learning Objectives - Develop an understanding of best practices for creating open source documentation - Learn how to collaborate with a community to develop documentation guidelines and templates - Gain experience in technical writing and editing - Learn how to use documentation tools and templates Expected Outcome - A set of documentation guidelines and templates that can be used by all Hyperledger projects - A style guide for Hyperledger documentation - A list of recommended documentation tools and templates - A plan for integrating the new guidelines and templates into existing Hyperledger projects - A series of blog posts or tutorials on how to use the new guidelines and templates
Hyperledger
The Carbon Accounting and Certification Working Group is developing an Operating System for Climate Action, which is a set of applications for obtaining and certifying data, creating tradeable tokens for emissions and offsets, and using DAO's to coordinate collective action. As part of this project, we're looking for technical writers who could help both document the technologies and how they could be applied to actual use cases. We've started with a few ideas and would like your help refining them with actual or potential projects. We'd also like help reaching out to and interviewing potential users of the applications to get their feedback on how they could be used. As part of this project, you will learn about 1) Blockchain technologies including Hyperledger Fabric and Ethereum 2) Applications such as Distributed Autonomous Organizations (DAO's) 3) Interviewing skills 4) Technical writing and documentation Expected Outcome Improved documentation of the blockchain carbon accounting applications. Tutorials on how to develop and enhance the applications. Use cases for the applications.
Hyperledger
Implementations of Hyperledger technologies span multiple industries, including finance, supply chain, trade, health, media, telecom and more. The beauty of our open source technology community is that anyone can use and build upon it for their specific needs and use cases. There are hundreds of implementations and capturing them in an easy to find and useful manner is a key enabling tool. Helping our community and the public to better understand use cases is a key part of helping advance the impact of distributed ledger technology. It validates ideas others have, provides avenues for reaching out and sharing lessons learned, and is a key part of building the Hyperledger community. In addition, we would also like to track academic papers and courses related to Hyperledger projects in order to develop an understanding of the academic landscape. In gathering and organizing the above information, the mentee will leverage their broad view of Hyperledger use cases as well as understanding of the overall blockchain space to identify potential opportunities for growth in uses or applications of Hyperledger technology. This can include use cases where our community isn’t as present, where we can explore doing further outreach and education. In addition, the mentee will make recommendations and potentially also work on developing ways for the use case and academic information to be leveraged for educational and ecosystem-building content and activities.
Hyperledger
Fablo is a tool to generate the Hyperledger Fabric blockchain network and run it on Docker. It's main goal is to provide a super-easy start with Hyperledger Fabric. It has a declarative approach - a whole network is described in a single file. Right now only the Docker environment is supported and we want add support for Kubertnetes Operators. Participating in the project will allow you to gain significant experience with Hyperledger Fabric network lifecycle and Kubernetes Operators. You will work with a "translation" of the current Docker-backed flow to Kubernetes. The expertise gained with working on the project is a good start in a broad range of professional careers related with Hyperledger Fabric and/or Kubernetes. It is also a great warmup before Certificated Fabric Administrator and for Kubernetes certifications. Fablo generates Docker compose file and some bash scripts for automation of the network configuration. We want to add an option to generate network configuration for Kubernetes Operators. We expect following outcome: - Fablo is able to generate YAMLs needed for K8S deployment. IIt can be implemented as a single YAML file deployed by single organization (minimal). It can be also split for multiple organizations for independent deployments (nice to have) - Fablo supports current Docker features for K8S (like, up, down, prune, chaincode upgrade.). The scope of supported features is flexible and depends on the work required for adding basic support for K8S.
Hyperledger
Blockchain Explorer is a GUI tool that allows users to view blocks, transactions, nodes, channels, chaincodes and other associated information about the blockchain network. The aim of this project is to enhance the existing application in-terms of new features and uplift the user-interface with the robust design. Blockchain explorer uses fabric-sdk to get the details from the fabric network and stores the data in the postgres database, which is later used by the explorer UI. The developers will get a chance to get involved in the entire software development life cycle with the proposal-implementation of new features, review the peer developed code, write the unit test cases, refining the existing code efficiently to adhere to the coding standards and much more.
Hyperledger
Minifabric supports deploy Hyperledger Fabric in both docker and K8S environments, however, it currently does not support Hyperledger Fabric running as k8s operators. Making Minifabric deploying Hyperledger Fabric onto K8S and running as K8S operators will allow hyperledger fabric network nodes with taking advantages of K8S operator benefit. This work will involve the participators to develop K8S operators, deploying K8S operator controllers and managing K8S operator life cycles, at the same time, the participators will be able to learn Fabric and Fabric deployment model. This is a great opportunity for anyone who would like to know K8S and know Hyperledger Fabric.
Hyperledger
Blockchain Explorer provides a graphical user interface to explore blocks, transactions, nodes, channels, chaincodes in a blockchain network. The goal of this project is to redesign the user interface of hyperledger explorer project to provide an easy as seamless experience for the user. The goal is to make Blockchain explorer as the common explorer tool for all the hyperledger DLT projects. Learning Objectives - To implement all the user research , analysis and design techniques to design a very compelling user experience for hyperledger fabric. - Gain an indepth understanding of Hyperledger DLT projects. - Developer user experience and user interface design skills. Expected Outcome - User flows , wireframes, style guide and high fidelity mockup of the new user interface design for Hyperledger Explorer
Hyperledger
Hyperledger Cactus is a blockchain decentralized 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. On the other hand Iroha (version 1.x) is great with asset management, and has functionality to store data, which makes those two projects a perfect fit! In previous HL Summer Mentorship Project the integration was successfully made (link). As a result of the project commands and queries from HL Iroha were integrated, it was Iroha 1.2, but after that year multiple features and changes was added to Iroha (e.g. Healthcheck). What is more - not all nice to have features was integrated (list of missing features). It is also important to make the configuration flexible to make its possible to set up connection between two different blockchain networks (e.g. Iroha → Iroha). In short, the project's goal is to: 1. Implement missing features + tests + documentation 2. Update Iroha version to newest in the integration. 3. Make the plugin configurable 4. Create tutorial demonstrating how to set up connection between multiple networks (at least Iroha - Iroha networks)
Hyperledger
A DID registry is a type of verifiable data registry that can be simply referred to as a role, a system performs to mediate the functionalities like create, verify, update, and deactivate the decentralized identifiers. The mentee will have an opportunity to learn -- The application and automation of the Decentralized Identity Hyperledger Aries and Ursa code base -- Public key cryptography -- Application of Hyperledger Ursa in enabling Zero-Knowledge proof -- Git, Shell Scripting, RUST -- Open source contribution, documentation, and sense of ownership Expected Outcome -- Command-Line utility to automate the process of creating a DID Registry for the members of organizations utilizing Github/Gitlab as Verifiable Credential Registry, On-boarding organizations, and features for easy management -- Proper test cases and documentations -- Codebase maintained with proper read me document
Hyperledger
One of the key use cases of blockchain integration is asset bridging: in essence, "locking" an asset (typically, a native coin or token) in a smart contract on its authoritative ledger and making available corresponding, newly minted (wrapped/shadow/...) assets on another. By now, bridging is supported by quite mature solutions in the cryptoworld; however, the same is not true for "consortial" distributed ledger technologies. At the same time, such functionality can be expected to become an important requirement in the not too distant future - Analysing the implementation approaches of standard "token models" (ERC20, ERC-721, ... - as far as this has been already done) in native Fabric chaincode and creating conceptual mappings between standard Ethereum token types and Fabric-native assets (including, but not limited to, the different authentication and authorization approaches). - Creating a brief review of the bridging approaches and mature technologies widely used in the cryptoworld. - Performing a requirement analysis for bridging assets from Fabric to Ethereum-based networks (and back), taking into account that the parties performing the bridging have to be explicitly given permission to do so by an authority and may be subject to regulatory requirements. - Based on the available open-source components, designing and prototyping a Fabric-Ethereum bridge fulfilling the requirements As the proposed project bridges multiple fields, creating a centralized solution.
Hyperledger
In the summer of 2019, Hyperledger ran a mentorship geared towards getting the Git version control tool to understand and use cryptographic credentials in decentralized identity (DID) documents to sign and verify commits. The root cause analysis led the project in the direction of creating a patch set for Git that enabled Git to use any signing tool more easily rather than just its existing support for GnuPG. Work is still ongoing to get those patches landed into Git and out in the wild. This mentorship anticipates the completion of that work and extends the previous work with the construction of a software application that can be called by Git to sign/verify commits using credentials stored in DID docs.
Hyperledger
The Learning Materials and Development Working Group at Hyperledger is looking for two enthusiastic mentees willing to scout and map existing opportunities to learn about DLT and Blockchain around the globe. Our Wiki Page is the entry point to the Galaxy of Hyperledger. Our team keeps a Resource Library of Hyperledger Projects and Tools, Use Cases, Key Terms, Learning Materials for Special Interest Groups and Working Groups, Templates, Meetups, Labs, Marketing, and News. As well as a sinopsis of current events, announcements, community events, requirements for Best Practice Badges, GitHub resources. We proof-read edX Blockchain courses for Linux Foundation (Hyperledger). We have 50+ registered and recorded meeting agendas. We want to identify and contact potential allies to link our inner Hyperledger Universe with the rest of the world. We need scouts to explore, register and map the outer territories beyond our community. Mentees shall learn how to structure a taxonomy of DLT / Blockchain Educational Opportunities, where to find them, and how to analyze their objectives and products. They shall build a comprehensive Global Directory of DLT / Blockchain Educational Programs, register their websites, identify their working teams, make initial contact, and identify their potential interest to become part of an Open Source Educational Alliance with LMDWG, Hyperledger, and the Linux Foundation.
Start with GSoC, European Summer of Code, Outreachy, or LFX — then drill into orgs.