Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
In recent years, containers have extended beyond their traditional cloud environments, becoming increasingly prevalent in remote and edge computing contexts. These environments often lack reliable internet connectivity, posing significant challenges in managing and running containerized applications due to difficulties in fetching container images. To address this, the project aims to decentralize container registries, making them more accessible to edge devices. The need for a satellite that can operate independently, store images on disk, and run indefinitely with stored data is crucial for maintaining operations in areas with limited or no internet connectivity. Harbor Satellite aims to bring Harbor container registries to edge locations, ensuring consistent, available, and integrity-checked images for edge computing environments. This proposal outlines the development of a stateful, standalone satellite that can function as a primary registry for edge locations and as a fallback option if the central Harbor registry is unavailable. Expected Outcome: The goal is to extend the proof of concept and demonstrate that such a solution practically works. Candidates should be able understanding and implementing the image (https://github.com/opencontainers/image-spec) and distribution spec (https://github.com/opencontainers/distribution-spec) to replicate images from a central registry to a registry on the edge location.
The Kyverno CLI does not have a formalized schema with proper validation for its test command. Create a formal schema which is documented allowing for full validation and related other capabilities which enhance its usage. Upstream Issue (URL): * https://github.com/kyverno/kyverno/issues/2323 * https://github.com/kyverno/kyverno/issues/2315 * https://github.com/kyverno/kyverno/issues/2302 * https://github.com/kyverno/kyverno/issues/2857 * https://github.com/kyverno/kyverno/issues/2945 * https://github.com/kyverno/kyverno/issues/3271
kruise-game contains two CRDs GameServer and GameServerSet. Game servers can be managed by deploying or changing the corresponding CR. However, in actual production use, a release or operation and maintenance action is often a combination of a series of operations on CR. For example, set the GameServer image tag with ids 1, 7, and 10 to v0.3; adjust the update priority of GameServer with ids 5, 9, and 11 before updating the game server, etc. Therefore, a set of APIs with operation and maintenance semantics is needed, which users can directly use or integrate into their own operation and maintenance platform to facilitate operation and maintenance operations. Expected Outcome: * A service component that includes multiple APIs
As Crossplane ecosystem expands, it's not unusual anymore to have 100s of CustomResourceDefinitions in a provider. A big part of this is thanks to code generation tooling we've been building. However, the changes we make with those tools may result in thousands of lines of changes and it's hard to tell whether there is a breaking change in given CustomResourceDefinition in those PRs. Today, we're checking manually to see if there is a breaking change and mark the PR as such so that the notice ends up in the release notes. We can have a GH Action that processes diff in package/crds folder and report breaking changes in the OpenAPI v3 Schemas of CRDs. It'd comment on the PR and automatically label it with breaking-change. This tool would be useful for the whole Kubernetes community that works to extend Kubernetes with CustomResourceDefinitions. We should document the variety of ways to pull packages from popular private registries, and also have testing in place to ensure we don't break any of the mechanisms from release to release.
We would like to develop an LLM-based financial data analytics application using open source LLMs, embedding models, the LlamaEdge application server, vector databases, and data processing tools. It will provide an open source "template" and showcase "best practices" for similar applications in this fast growing application area. Expected Outcome: * Create a data processing pipeline in Python or Rust to automatically * collect public company’s SEC 10-Q quarterly reports and press releases. e.g., [Apple 10-Q](https://www.sec.gov/edgar/browse/?CIK=0000320193) and [Apple press release](https://www.apple.com/newsroom/2024/05/apple-reports-second-quarter-results/) * generate a summary for each SEC 10-Q and press release documents using an LLM service such as [LlamaParse](https://docs.llamaindex.ai/en/stable/llama_cloud/llama_parse/) or [EYELEVEL xRay](https://dashboard.eyelevel.ai/xray/) * create and continuously update a vector database with the summary and original text. The vector is computed from the summary to improve search efficiency. * Create a server-side RAG app that can chat with the vector knowledge base of financial statements. * Evaluate the answer quality * Explore LLM function calling to incorporate real-time information and actions
Inspektor Gadget is an eBPF tool and systems inspection framework for Kubernetes, containers and Linux hosts. In this project, you will write a new gadget in BPF and WASM to detect deadlocks in applications. The BPF program will be attached on mutex locks and mutex unlocks functions with uprobes. The WASM program will build a mutex wait directed graph and look for cycles. Then, the gadget will display the stack trace showing the mutex locks causing the deadlock. This project builds upon previous work: - In a previous mentorship project, Inspektor Gadget gained support for uprobes and kernel stack traces (https://www.inspektor-gadget.io/blog/2024/06/supporting-uprobe-based-gadgets-lfx-mentorship-report/). - BCC tools include deadlock.py doing the same: https://github.com/iovisor/bcc/blob/master/tools/deadlock_example.txt and https://github.com/iovisor/bcc/blob/master/tools/deadlock.py However, this project still has challenging issues to resolve: - Inspektor Gadget does not support dumping stack traces from userspace applications yet Expected Outcome: A new gadget detects lock order inversion and prints the stack traces where each mutex was acquired.
This project focuses on two major enhancements for the Chaos Center (https://github.com/litmuschaos/litmus/tree/master/chaoscenter). First, it aims to enable the support for multiple project owners, a feature highly requested by users. This addition will allow for more collaborative and flexible project management within the Chaos Center. Second, the project will develop an API for downloading logs, providing users with easier access to log data. Furthermore, there's a need to update the API documentation to reflect these new changes and ensure that users have the latest information for seamless integration and usage. Expected Outcome: The successful completion of this project will result in the Chaos Center supporting multiple project owners, fostering collaborative and efficient project management. The new log download API will enhance user experience by simplifying access to log data. Additionally, the updated API documentation will ensure that users have clear and current guidelines, supporting better utilization of the new features.
Jaeger is a widely used distributed tracing platform. This project aims to integrate Small Language Models (SLMs) and Large Language Models (LLMs) into the Jaeger ecosystem to provide intelligent trace analysis. Key features include natural language search mapping (mapping English queries to Jaeger's internal search parameters), contextual analysis, and summarization ("Explain this Span" or "Explain this trace"). The project involves backend integration using Go and LangChainGo, and frontend integration within the Jaeger React UI. Expected Outcome: A working "Natural Language Search" input that populates the Jaeger search form, contextual "Explain" buttons for errors and spans, a robust backend implementation using langchaingo supporting local models (e.g., Ollama) via YAML config, and comprehensive documentation.
Support the mutateExisting rule in Kyverno CLI Expected Outcome: - Allow users to be able to apply mutate existing policies to resources from 1. file systems; 2. clusters.
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
Crossplane is in use at scale in many production environments, but we often get feedback that there are many obstacles to learn Crossplane and get to a successfully built production-ready control plane. A major reason for this learning curve is the lack of supporting tools and experiences on top of core Crossplane that could accelerate the community’s attempts to successfully build their platforms. These higher level experiences have recently become a focus for the project and we want to keep delivering awesome experiences that make Crossplane easier to use. Expected Outcome: We expect the mentee to design and code multiple improvements to the Crossplane tooling from the issue linked below. We will start with smaller scoped issues to ramp up and then focus on a bigger deliverable such as adding validation for Crossplane Functions. By the end of the term, the mentee will have multiple code PRs merged into the Crossplane codebase.
Volcano-global is a multi-cluster scheduling project designed for cross-cluster resource management. Currently, the project lacks a comprehensive end-to-end (e2e) test suite to ensure stability across complex multi-cluster environments. This project aims to build a reproducible e2e test framework using Ginkgo and Kind, ensure each feature of Volcano-global is covered by test cases. - Expected Outcome: - A functional e2e test framework integrated with GitHub Actions workflows. - Scripts for automated deployment of Volcano-global and bootstrapping of Karmada multi-cluster environments. - Test cases covering key scenarios: resource quota & priority, cross-cluster vcjob scheduling, data dependency aware scheduling, and hyperjob scheduling. - Comprehensive documentation, including test design docs and guidelines for extending e2e tests in the future.
Meshery's UI is powerful and utilizes frameworks like Next.js and Material-UI. However, it relies on outdated technology stacks, resulting in performance inefficiencies and increased maintenance overhead. Expected Outcome: Migrate from MUI v4 to MUI v5 and fully utilize features of Nextjs v13. Migrate all class based components to function based component. Reduced code complexity and improved maintainability for long-term sustainability. Responsive and accessible UI that adapts to diverse devices and user needs.
Chaos Engineering is the discipline of experimenting on a system in order to build confidence in the system’s capability to withstand turbulent conditions in production, ref. https://principlesofchaos.org/, i.e. to induce errors on a system and see how it behaves. eBPF can be used to induce such errors on a system, it can change the return value of a kernel function, drop or modify network packets, etc. The goal of this mentorship is to implement a set of gadgets for Inspektor Gadget that helps causing system chaos. These are some ideas of the gadgets that should be implemented: - DNS: Drop/modify/add latency DNS requests and/or responses based on - The container or process performing it - The target URL - The DNS server - TCP/UDP: Drop network packets based on - Destination / Source IPs - Originating or destination pod or process - Simulate system call failures based on - Container or process performing the syscall - Syscall The gadgets should expose metrics with the number of times it induced failures, and possibly also provide notifications when those errors were induced. Expected Outcome: A set of gadgets with the above functionality should be implemented and merged on the upstream Inspektor Gadget repository. Those gadgets should include documentation and tests.
Background: Current flows from RISC-V Sail specification to downstream implementations have manual steps which are time-consuming and can introduce errors.A lack of familiarity with Sail and OCaml presents a barrier to adoption of Sail as the basis for automated downstream implementations: emulators, simulators, compilers, assemblers, disassemblers, instruction stream tools, documentation, etc. Proposal: - Create an accessible Sail backend. - Extract salient information. - Transform it into an accessible database (JSON). - Survey projects dependent on RISC-V ISA for how that dependency is realized. - Utilize JSON to directly and automatically generate downstream source that is currently generated by hand. - Create a React-based interactive RISC-V ISA reference by directly importing the JSON database. Benefits: The backend can serve as a model for creation of additional Sail backends. The JSON database itself may be sufficient for many downstream uses. Creating downstream source shows feasibility, and a process for a fully-automated downstream flow. Additional collaboration with the effort to transform Sail into documentation is warranted. Much of the effort to transform Sail into JSON is complete, but there is still significant effort ahead: - enhanced parsing - enhancing the RISC-V Sail specification itself with more required content Much of the effort in creating an interactive web site is complete, but there is work to support the incorporation, display, and filtering.
Develop robust CoRIM security features integrated into Veraison’s services, enabling multi-signature and enhanced security for integrity verification. Expected Outcome: Develop robust CoRIM security features integrated into Veraison’s services, enabling multi-signature and enhanced security for integrity verification.
With WasmEdge serving as one of Runwasi’s standard runtimes, and as our C++-implemented library continues to evolve, we also need a verification process integrated into Runwasi to streamline and validate the stability of both container and cloud environments. Expected Outcome: 1. A concise GitHub workflow demonstrates Runwasi end-to-end testing on Kubernetes. a. Need to design an interactive application scenario that supports multiple nodes b. Try to incorporate the use of the WasmEdge plugin into this scenario 2. Document
Description: Kubernetes uses OWNERS files to delegate responsibility over different parts of the codebase. These files are also used in the code review process. Unfortunately, over time, there are lots of OWNERS files which have languished and have stale information. Since the velocity of a project is also determined by the number of people reviewing code, it is essential to keep the OWNERS files up-to-date. To ensure this, the maintainers project was created. This internship involves improving maintainers through adding new features and integrating the tool in suitable automation so that it is actively used by the community to signal out-of-date OWNERS files. A stretch goal would also be to improve similar automation tools used to handle GitHub membership for the community.
Hyperledger Iroha has Smart Contracts from Hyperledger Burrow. It was done in internship project in 2019, then integrated into main Iroha code in version 1.2. Unfortunately integration does not integrate all Iroha commands and queries (currently only: TansferAsset and GetAccountAssets are integrated). So task is to integrate all commands and queries and also permissions. The mentee will be able to learn: 1) ways of integrating different projects from architectural point of view, 2) architecture of Iroha (1.x) and optionally Burrow, 3) work in true spirit of open-source, communicating with both Iroha and optionally Burrow community, joining calls and using other community tools, 4) writing documentation, so anyone in the community could use the results of their work, 5) ollowing rules and standards of open-source projects created by hyperledger, 6) Intern would get experience in virtual machines Expected Outcome Documented integration of all Iroha (version 1.x) commands, queries and permissions with unit tests.
Implement a new policy rules autogen system based on extracting the pod spec from higher-level controllers. Expected Outcome: 1. The new system works by applying the same rules on the extracted pod spec instead of generating new rules for higher-level controllers 2. The system treats pods and higher-level controllers exactly the same from a policy stand point
Tetragon currently depends on Cilium to look up pod information by their IP addresses. The goal of this project is to remove this Cilium dependency by implementing a Kubernetes operator that provides this information. The idea is for this operator to maintain a new custom resource that provide a mapping from IPs to the small subset of pod information that Tetragon needs. - Expected Outcome: - A Kubernetes operator that maintains IP to pod info mapping used by Tetragon. - The operator should be installable via Helm as a Kubernetes deployment. - Replace Cilium dependency in the code base with this new custom resource. - Some performance benchmarks in a high pod churn environment.
As a buildpack user using `pack`, I would like to be able to inspect the final app image and determine where the source of the code is located as well as what version (keeping in consideration SCM systems) was used.
The [OpenVINO](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/download.html) official release supports various platforms. WasmEdge supports the WASI-NN proposal with OpenVINO backend now, but only in Ubuntu 20.04. In this project, we want to porting and integrating the OpenVINO installation for the multiple platforms such as MacOS, Windows, or manylinux with the WasmEdge WASI-NN plugin.
Update the syntax highlighters adding support for macro statements, highlighting commas and parentheses, and support for variables. Also, add new snippets to test different aspects of the syntax highlighting grammar.