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.
The current MoFA architecture tightly couples agents to a single inference backend (e.g., OpenAI, Ollama), making switching providers, handling failures, or optimizing cost and latency difficult without modifying agent code. This project introduces the Cognitive Compute Mesh (CCM): a distributed inference layer implemented as a new mofa-gateway crate that transparently sits behind the LLMCapability interface. Instead of acting as a central gateway, CCM enables a mesh architecture, where every node (local, cloud, or edge) participates in both computation and routing. The system is built around three core components: - A typed Inference Request Protocol (IRP) that standardizes communication across all providers - An intelligent routing layer that dynamically selects backends based on latency, cost, capability, and health - A production-grade RAG pipeline with hybrid retrieval (dense + BM25), reranking, and caching CCM ensures that agents become backend-agnostic, enabling seamless failover, cost optimization, and hybrid local-cloud execution without code changes. Deliverables: - mofa-gateway crate implementing LLMPlugin - Backend SDK for integrating new inference providers - Support for OpenAI, Anthropic, Ollama, and OminiX-MLX - Distributed routing with circuit breakers and health tracking - Full RAG pipeline with vector storage support - Documentation, benchmarks, and demo showing backend-agnostic agents This project aims to establish a protocol-level abstraction for AI inference, similar to how HTTP abstracted networking enabling “write once, run anywhere” for AI agents.
The Julia GPU ecosystem allows users to write array programs that run seamlessly across NVIDIA, AMD, and Intel GPUs. This functional portability relies on GPUArrays.jl, which defines the common interface implemented by all vendor packages. However, several foundational operations currently lack shared implementations. Operations such as reverse, findall, accumulate!, and mapreduce either crash on backends lacking a vendor override or silently degrade to CPU execution by copying data back and forth. A direct source audit of GPUArrays.jl (v11.4.1), CUDA.jl, AMDGPU.jl, oneAPI.jl, and Metal.jl confirmed these gaps: reverse and findall are entirely absent from the shared fallback layer, accumulate! exists only as a scalar CPU fallback, and mapreducedim! is declared as an error("Not implemented") stub, forcing every backend to maintain isolated, vendor-specific implementations. This project resolves these portability gaps by establishing a cleaner, more robust architecture: moving critical GPU kernels upstream to AcceleratedKernels.jl (AK.jl) while refining GPUArrays.jl into a lightweight, pure delegation layer. Building upon the newly introduced KernelIntrinsics API, this approach implements highly optimized, vendor-neutral kernels directly within AK.jl. Because Julia’s multiple dispatch inherently prefers the most specific method, routing AnyGPUArray fallbacks to AK.jl means backends with existing optimized vendor methods remain untouched, while backends missing the functionality automatically receive high-performance GPU execution instead of a crash or silent slowdown.
The currently used styling system has a number of major shortcomings: its over-complicated and full of nuances, which often leads to unpredictable behavior; the current style files structure and absence of validation tools makes it easy to do mistakes and hard to debug them / hard to notice undesired side-effects; the current inheritance mechanism doesn’t work well for “sub-styling” (adding new styles by specifying only changes over the base style). A major refactoring of the current system will speed up development of the current and planned map styles, increase their robustness and hence save time on maintenance / bug fixing, open up possibilities for perspective style enhancements. Requirements for a new better system: - predictable and easily debuggable, makes it hard to break things - style files are nice, clean and compact - promotes stylistic standards, e.g. standard font and icon sizes for various zoom levels - supports easy and efficient sub-styling - simple enough to be used by enthusiastic users, so that they could create custom styles - powerful/flexible enough to describe the styles without much repetition - future-proof, i.e. it should be easy to add support of dynamic styling, svg icons or other perspective styling features planned by the Organic Maps team As a result, Organic Maps will run on a new styling system, which includes - a new styling language syntax specification, including its documentation - current main and vehicle style files migrated into a new format - a compiler of new format style files into the binary Google protobuf format used by the rendering engine
This project involves the integration of AlphaMissense, an innovative tool for predicting the pathogenicity of missense mutations, into two established platforms: Genome Nexus and cBioPortal. My Objectives and Deliverables are: - Integrate AlphaMissense pathogenicity predictions into Genome Nexus API responses, enriching genetic variant analysis with detailed pathogenicity scores. - Display AlphaMissense predictions within the Genome Nexus variant pages and add dedicated data columns in the cBioPortal mutation tables, complete with functionalities for sorting, filtering, and downloading. -Add AlphaMissense pathogenicity prediction and score into Genome Nexus annotation pipeline as two new columns in the annotation result file The project will be executed in phases, starting with initialization and planning, followed by backend and frontend development to integrate and visualize AlphaMissense data. Subsequent phases will focus on testing, deployment, and documentation, concluding with a final review and official launch. Post-launch, the project will enter a maintenance and support phase to address any arising issues and incorporate user feedback. Backend development will utilize Java and Spring Boot for integrating the AlphaMissense plugin into the Genome Nexus API. Frontend components will be developed using React and TypeScript, ensuring a dynamic and user-friendly interface for displaying genetic predictions.Comprehensive testing phases, including unit, integration, and User Acceptance Testing, will ensure the reliability and accuracy of the integration. This integration represents a significant leap forward in personalized medicine. By making pathogenicity predictions more accessible and interpretable, this project aims to support advancements in genetic research and clinical decision-making, ultimately contributing to improved patient outcomes.
Apache ShardingSphere is positioned as a Database Plus, and aims at building a standard layer and ecosystem above heterogeneous databases. It focuses on how to reuse existing databases and their respective upper layer, rather than creating a new database. The goal is to minimize or eliminate the challenges caused by underlying database fragmentation. ShardingSphere parser engine is the core of ShardingSphere, It helps users parse a SQL to get the AST (Abstract Syntax Tree) and visit this tree to get SQLStatement (Java Object). At present, this parser engine can handle SQLs for MySQL, PostgreSQL, SQLServer, openGauss and Oracle. However, there are still many statements that are not supported yet. Therefore this project proposes to Solve unsupported Postgres sql about alter statements for ShardingSphere parser and also proofread and optimize the grammar wherever needed. This project would require to proofread through DDLStatement.g4 to analyze existing grammars and optimize them (essential), write grammar for unsupported alter statements referring to the official PostgreSQL documentation (essential), implement visit methods for the statements (essential), add new corresponding SQL cases and expected parsed results (essential), Run SQLParserParameterizedTest and UnsupportedSQLParserParameterizedTest to make sure there are no exceptions (essential). Successful Implementation of the project will add proper support for PostgreSQL Alter Statements ensuring there are no exceptions for the following statements, ALTER OPERATOR, ALTER POLICY, ALTER PUBLICATION, ALTER ROUTINE, ALTER RULE, ALTER SCHEMA, ALTER SEQUENCE, ALTER SERVER, ALTER STATISTICS, ALTER SUBSCRIPTION, ALTER TABLE, ALTER TEXT SEARCH,ALTER TRIGGER, ALTER TYPE, ALTER VIEW. This project will significantly improve the ShardingSphere parser engine.
Libraries worldwide face challenges in adopting digital lending due to restrictive licenses and costly, vendor-locked systems that limit independence. Lenny is an open-source, self-hosted lending system inspired by the Internet Archive and Koha. Its mission is to give libraries ownership of their digital collections while offering a flexible and cost-effective alternative to proprietary platforms. At its core, Lenny based on python features a FastAPI backend that handles borrowing, returning, and waitlists, with support for Readable, Borrowable, and Print-Disabled books. Security and compliance are provided through LCP DRM and Geo-IP restrictions, while PostgreSQL triggers automate loan expirations. An OPDS feed enables integration with Open Library, Thorium, and other reading systems. Deployment is simple with Docker (Alpine + Nginx), and a React dashboard allows librarians to set lending rules like loan durations and waitlists. To improve accessibility, the companion Lenny-app (TurboRepo monorepo) includes: 1. A sandbox demo preloaded with 500+ e-books to showcase the system in action powered by Lenny. 2. A documentation site that supports integration, open-source contributions, and extensions. Built with TypeScript, React, Next.js, Node.js, and Express.js, Lenny-app is production-ready yet flexible for experimentation. Together, Lenny + Lenny-app deliver both the backend infrastructure and the user interface needed to power community-driven digital lending. By combining secure architecture, a ready-to-use demo, and developer-focused documentation, Lenny provides libraries with a scalable and future-proof solution to manage digital lending independently and expand access for their patrons.
My proposal aims to increase the level of context that Pwndbg provides when stepping through a binary by “annotating” the results of instructions. Alongside the disassembled machine instructions in the dashboard, there would be text to indicate the action that each instruction takes, such as moving values between CPU registers, writing data to memory, or doing a mathematical operation. We would resolve the concrete values that memory and CPU registers take on after each instruction, providing relevant information that the user would otherwise have to fish out manually using a GDB command that varies depending on the context. Pwndbg is starting to support this annotation feature for the x86 architecture. My project would add these annotations to other architectures supported by Pwndbg, namely 32-bit Arm, 64-bit Arm, RISC-V, and MIPS. This not only aids in debugging and reverse engineering, as you would gain much-needed context as to the results of instructions, but there is also an educational benefit in that you can visually see what each instruction is doing while stepping through a binary. We would additionally create annotations for future instructions in the disassembly view using emulation. By combining the Unicorn Engine, a CPU emulator framework, with the Capstone Engine, a disassembly framework, we can provide the user with insight into the next handful of instructions, providing more context and increasing debugging efficiency. Deliverable - A series of pull requests which add annotations for instructions for Arm, AArch64, RISC-V, and MIPS inside the “disassembly” view of the Pwndbg dashboard - A rewrite of the parent class API to make adding annotations to new architectures more simple - Add the ability for the recursive printing of pointers inside the annotations to provide enhanced information on pointers inside heap memory, such as internal heap manager metadata - Documentation and tests to aid future contributors and reduce chance of regressions
This project focuses on redesigning the ListView component in MIT App Inventor to address key architectural, performance, and cross-platform consistency issues. Currently, the component suffers from inefficient full adapter rebuilds, lack of a structured data model, and inconsistencies between Android and iOS implementations. These issues lead to performance overhead, unreliable behavior, and poor developer experience, especially for beginners. To solve this, the project introduces a structured, phased approach: Core Refactor (Reliability): Introduce a dedicated ListDataModel to manage items, selection state, and filtering. This eliminates full adapter reconstruction and enables efficient incremental updates. Cross-Platform Consistency (Continuity): Establish a behavioral contract and parity tracking system to systematically align Android and iOS implementations, fixing missing features, type mismatches, and runtime inconsistencies. API Expansion (Extensibility): Add block-level operations such as AddElement, RemoveElement, UpdateElement, ScrollToElement, and SelectionElements, along with full multi-select support. User Experience Improvements: Enhance the Designer with a UIBinder-based list editor, keyboard navigation, and introduce a swipeable (carousel-style) layout for modern UI interaction. Deliverables Modular ListDataModel architecture with incremental update support Eliminated full adapter rebuilds and improved performance Android–iOS feature parity with validated behavior New block-level APIs and multi-select functionality Redesigned Designer editor with improved usability Swipeable ListView layout implementation Comprehensive testing, documentation, and backward compatibility assurance This project aims to make ListView more scalable, consistent, and beginner-friendly, while establishing a maintainable foundation for future enhancements.
<p><a href="https://play.google.com/store/apps/details?id=org.kde.marble.maps" target="_blank">Marble Maps</a> brings the highly detailed OpenStreetMap to your Android devices. It features a crisp, beautiful map with an intuitive user interface. This project is about extending it to support indoor maps (e.g. selecting and showing different levels of a building). The following are the goals to achieve from this project:</p> <ul> <li>Marble extracts <a href="https://wiki.openstreetmap.org/wiki/Simple_Indoor_Tagging" target="_blank">indoor related OSM tags</a>.</li> <li>Floor and connection elements (e.g. room, wall, door, staircase) are shown in the map. Similar to <a href="http://openlevelup.net/?lat=42.80043008955188&lon=-1.6367550194263458&zoom=19&tiles=0&level=0&transcend=1&unrendered=0&buildings=0&photos=0&notes=0" target="_blank">OpenLevelUp</a>.</li> <li>User interface to select floor levels and filtering of the map view based on the active floor level.</li> <li>Automatic adjustment of the floor level user interface (hide it when there are no indoor map elements in the view,<br> select minimum/maximum floor level automatically).</li> <li>Further adjustments to the UI to make the whole experience for the end user a delightful one.</li> <li>Extend libmarblewidget with additional classes and objects to be able to support all the above mentioned points.</li> <li>Improve indoor rendering.</li> </ul>
The first genome-scale models of metabolism appeared in 1999 and 2000. In the following years fundamental Microbial Systems concepts were developed such as in silico methods and algorithms to analyze their properties. Genome-scale Metabolic models (GEMs) built on genome-scale metabolic network reconstructions (GENREs) are capable of deciphering the complex interactions occurring in bacteria, through predictions of the possible mechanism underlying these interactions. dingo is a Python package that supports a variety of methods to sample from the flux space of metabolic models, based on state-of-the-art random walks and rounding methods. Aim of this project is to enhance dingo by incorporating a preprocessing class to reduce and simplify metabolic networks, by removing certain reactions and metabolites. To identify correlated reactions, i.e. the flux of one depends on the others, I will develop a post-processing function to calculate correlation metrics and compare pairwise reaction fluxes. Additionally, another function will create graphs from the correlation matrix aiming to predict metabolic pathways. In the second half of the project, I will implement approaches for building microbial communities models. Two main approaches are to be implemented: Bag of Genomes and Bag of Genes. I will develop : a new class (“dingo.Community()”) that will read and store a community model of two microbes based on the user’s approach of choice. Its output will be then used as input to the dingo.PolytopeSampler to proceed with sampling steps. Sampling in the community flux space with the different sampling methods already supported by dingo and benchmarking of the community modeling approaches against real data will be delivered. Refactoring current dingo functions to adjust the new functionality will be done too.
The current CGAL Python bindings expose powerful computational geometry algorithms, but they've accumulated real usability problems: method parameters show up as arg0, arg1, arg2 rather than meaningful names, docstrings are either absent or embedded so deeply inside binding code that they obscure the logic itself, CGAL's Named Parameters system isn't available from Python at all, and the CI pipeline isn't running. More critically, I found and documented 7 crash scenarios where Python objects outlive freed C++ DCEL memory → situations that kill the interpreter with a segfault instead of raising a Python exception. Over the past three months I've been working directly in the codebase building the foundation for this project. I've added nb::arg() parameter names to AOS2 binding methods, written inline docstrings following CGAL's own documentation style, built a 7-flag CMake check system aligned 1:1 with CGAL's macro structure, and validated a working 8-kernel CI pipeline before this proposal was even submitted. I've also worked through the Named Parameters challenge far enough to identify the property map type-bridge problem → the part that makes Weeks 7–8 genuinely hard. The deliverables for the 12-week program are: complete named parameter coverage across AOS2 binding files, full docstring coverage for AOS2 methods, 7 CGAL-aligned CMake precondition flags with fixes contributed upstream to CGAL C++, Python-accessible Named Parameters for key PMP functions (compute_vertex_normals, smooth_mesh, triangulate_faces), bindings for at least one currently unbounded package, and a production-ready 8-kernel CI pipeline with integrated test coverage.
Project Title: Flutter Badge Magic App Mentors: Aditya, MarioB, cweitat Problem: The current Badge Magic app offers limited customization (fixed fonts/colors), lacks interactive features, and restricts users to basic animations and Bluetooth configurations. Additionally, platform-specific deployment and unresolved bugs hinder accessibility and user creativity. Solution: Revamp the Flutter-based app to deliver: Advanced Customization: Support multiple fonts (Google Fonts integration), hex-code color pickers, and 8 editable animation storage slots. Interactive Games: Integrate Snake and Tetris with swipe/tap controls optimized for LED displays. Scalability: Auto-adapt content for diverse LED badge sizes (e.g., 11x44 to 16x45 matrices). Firmware Upgrades: Enable "Bluetooth always-on" mode and power management for stable, energy-efficient connections. Multi-Platform Reach: Automate CI/CD pipelines (GitHub Actions) for Windows, Linux, macOS, and web builds. Deliverables: Feature Enhancements: Font/color picker, editable animation storage (8 slots). Mini-games (Snake, Tetris) with collision detection. Firmware updates for advanced badge configurations. Cross-Platform Support: CI/CD workflows for 5+ platforms/app stores. Testing: 10+ unit/integration tests (90% coverage). Documentation: User guides, API references, and Quick tutorials. Bug Fixes: Resolve existing issues for a polished user experience. Impact: Empower users to create vibrant, interactive LED displays effortlessly while ensuring seamless performance across devices and platforms.
The CHAOSS community develops metrics, practices, and software for measuring open source software community health and sustainability. Augur and Grimoirelab are two powerful open source community health analytics projects supporting the CHAOSS mission. In particular, each has implementation of select metrics based on an expanding set of implementation-agnostic metric definitions associated with various focus areas. The CHAOSS Metrics Model Working group defines metric models, which integrate multiple CHAOSS metrics in a way that makes it easy for end users such as community managers to get a more comprehensive measure of an open source community. Currently, Conversion Rate can be defined as a metric or metric model. It measures the rates at which new contributors to an open source project move through the "contributor funnel" toward sustained contribution and/or community maintainership. There is no implementation of the Conversion Rate metric or metric model in CHAOSS software yet. This project aims to build a novel implementation of Conversion Rate as a metric model that is based on a minimum number of atomic metrics and has maximum reuse of existing implemented metrics as well as common metric model calculation code supporting all types of conversion rates. A simple config file based UI for entering parameters and filters by the users is all it takes to run the metric model. New metrics will be implemented first in Jupyter Notebook as reference code and can later migrate into Grimoirelab backend (for sharing with future new metric models or reports) along with data collection and enrichment extensions. The Metric Model calculation code and methods, and a common visualization interface will be also implemented in Jupyter Notebook, followed by a deployment with OpenSearch Dashboards visualization.
This project aims to deliver a fully-featured, cross-platform canvas-based editor for the Magic ePaper Badge, built entirely in Flutter without relying on third-party libraries. The application empowers users to create intricate badge designs with a highly customizable interface tailored specifically for ePaper screens, supporting tri-color rendering (red, white, black) and precise editing controls. Key features include a custom drawing canvas with gesture-based freehand and line drawing tools, a text overlay system with support for font selection, scaling, rotation, and locking, and an image import module allowing for multi-image manipulation on the canvas. A layer manager provides real-time reordering of image and text overlays, mirroring professional design software like Photoshop. A polished preview and export pipeline ensures clean final renders. Users can crop and adjust the final image with brightness and contrast controls before exporting it at the badge’s native resolution (240x416). The result is optimized for both BWR and BW UC8252 display variants. The project also includes robust NFC integration. I resolved critical issues in the original codebase, such as improper handling when NFC was disabled. I implemented a native Android method that navigates directly to the system’s NFC settings screen, significantly improving UX and cross-device reliability. The app now ensures seamless transmission of finalized designs to the ePaper badge over NFC. By implementing all functionality from scratch, this project delivers a performance-optimized, extensible editor tailored for the Magic ePaper Badge ecosystem, advancing FOSSASIA’s vision of accessible, user-driven customization tools.
This project aims to enhance both user and contributor experiences for the Resonate App by implementing critical quality-of-life features, improving accessibility, and preparing it for public release. To achieve this, the following deliverables are planned: 1. Make the app fully responsive by replacing fixed dimensions with LayoutBuilder and Flex widgets for a consistent UI across devices. 2. Stabilize the codebase and prioritize deployment of Resonate v1.0.0 to the Play Store and App Store. 3. Implement automated testing in Flutter targeting 90%+ code coverage to prevent regressions and ease PR reviews. 4. Set up CI/CD pipelines to automate deployment on updates to the main branch. 5. Complete the partially implemented Text Chat feature and add in-app notifications. 6. Add Internationalization (i18n) to support multiple languages. 7. Improve the Pair Chat experience by allowing users to select who to chat with from a list. 8. Expand the Search functionality to include Creators and Users, and introduce a "Follow Creator" feature. 9. Add a Friends System to enable one-on-one calls. 10. Introduce TTS and STT features in audio rooms for accessibility to non-verbal users. 11. Add Host Controls using the LiveKit API to allow moderation in rooms. 12. Enable creators to start Live Chapters, which will be recorded and uploaded automatically. 13. Replace current Appwrite search queries with Meilisearch to support scalable and advanced search capabilities. 14. Conclude the project with final testing, merging of features, and deployment of Resonate v2.0.0. This project will ensure Resonate becomes production-ready while staying contributor-friendly and inclusive for all users.
The LiftOver2D project aims to develop a high-performance tool for converting Hi-C matrices between different genome assemblies and binning schemes. This functionality is essential for integrating data from various sources and experiments — especially with the growing popularity of multi-omics approaches and the increasing availability of public datasets. Existing solutions, such as HiCLift, offer partial support but often fail to provide an optimal balance between accuracy and performance, particularly in cases of partial bin mismatches or complex remapping scenarios. LiftOver2D seeks to overcome these limitations by leveraging background contact distributions at the bin level, allowing for more precise and efficient remapping. The main goal is to design a method that achieves an acceptable trade-off between accuracy and speed, ensuring the tool is practical for real-world bioinformatics pipelines without sacrificing data quality or runtime efficiency. During the project, we plan to develop a custom model for bin-level remapping and optimal bin-to-bin matching across genome assemblies, and test our tool on various experiments and organisms using publicly available data from open databases (such as NCBI GEO). We aim to maximize performance and parallelization using both high-level data frameworks (like Dask or Polars) and lower-level languages where appropriate. The resulting algorithm will be wrapped into convenient packages for Python, R, and the command line. We also plan to collaborate with major tools in the Hi-C ecosystem (such as Cooler or Muon for multimodal experiments) to integrate our functionality into widely-used frameworks. In the long term, LiftOver2D aspires to become a community-standard solution for fast remapping of 2D genomic contact data. The development will be carried out as an open-source project in collaboration with the community and aligned with NumFOCUS’s mission to support sustainable scientific software.
I propose to augment the current project by implementing pending pipeline features which will drastically improve the security and capability of the base application. Specifically I propose implementing secure RSA encryption to the messaging service, implement secure file sharing with audio and video support and enable user discovery on a WiFi network using UIDs RSA encryption I propose using the rsa_encrypt library in dart to secure the chat service being created between two clients on the same peer network. When two clients are connected on the same peer network, a connection is created using FPTP protocol. This project proposes to use rsa_encrypt to create a security layer over the FPTP layer. Hence the chat service is secure from other possible listeners on the peer network. Secure file sharing I propose to extend the messaging service with file sharing capabilities. We transcribe the file stored in the client’s local storage into raw metadata and securely stream the bytes to the connected client using the RSA encryption layer. The client checks for the file type using MIMETypes and decodes the bytes into the intended file. This implementation is expected to use the dart:convert library for encoding and decoding. The challenge which I aim to surpass is encoding the raw bytes through the RSA layer to ensure that unauthorized listeners cannot access the raw bytes. File Viewing I propose to implement in app file previews for supported file types using open-file-x and also enable in app viewing for image and video file types. User Discovery on a Local Network The challenge here would be for the application to persist UIDs which can be advertised over the WiFi network. Flutter does not have the capability to access users connected to a WiFi network unless the application is the router. Hence I propose to use mDNS to allow the devices to broadcast their presence on the same network without needing a central server.
My proposed project aims to enhance the Borg ecosystem by tackling three main areas: Filter option in diff and extract view in Vorta, implement live binary tests in Vorta, and bootstrap a Borgmatic restore from nothing. These improvements will help users more efficiently and effectively manage their backups, improve testing processes, and facilitate disaster recovery. Firstly, I will implement a search function that allows users to filter files by search string in Vorta's diff and extract view. I will also add the "Change" filter to the comparison view, which will filter only removed, added, and modified files. This task also includes adding syntax to allow advanced filtering and filter by size range as a stretch goal. These enhancements will help users easily find and manage their backup files. Secondly, I will improve BorgBackup testing by implementing live binary tests in Vorta. Currently Vorta contains stdout and stderr mock files for the Borg JSON output of various commands for testing purposes but there’s no actual running of the commands. Moreover, it only supports one mock file while Vorta supports multiple Borg versions where output syntax may vary. This project aims to improve Vorta Testing by implementing live binary tests that run on multiple actual Borg versions/binaries. I'll also integrate live binary tests with Vorta's CI/CD pipeline. Finally, I will implement bootstrap functionality in Borgmatic to restore backups from nothing, enabling users to easily recover their data in the event of a disaster. I will implement this feature by providing clear and comprehensive documentation, which will outline the steps required to perform a Borgmatic restore from scratch. This will significantly improve disaster recovery capabilities and reduce the risk of data loss.
The Sugarizer Human Activity Pack project aims to enhance the educational tools provided by Sugar Labs by developing two engaging and interactive activities. The first, the 3D Human Body Activity, will expand on the existing anatomical visualization tool by integrating multiple 3D models, including skeletal, human body and organ system. It will allow users to toggle between different layers, interact with body structures dynamically, and engage in real-time collaborative learning. Additional features such as interactive quizzes, UI/UX refinements, and localization support will ensure accessibility and usability across different regions and devices. The second component, the Stickman Animation Activity, will introduce an interactive keyframe animation tool where users can manipulate a stick figure by adjusting its nodes to create animations. This tool will support essential animation features such as playback, speed control, and exporting animations as videos. It will also include a collection of pre-designed templates for common movements like running, jumping, and dancing. A standout feature of this activity is the ability to import a photo of a human body and generate a corresponding stick figure in the same pose using AI-assisted pose detection. By the end of the project, Sugar Labs will gain two fully functional, optimized, and localized activities that provide immersive learning experiences in human anatomy and animation principles. The enhancements to the 3D Human Body Activity will enable students to explore anatomy in a more interactive and engaging way, moving beyond static textbook images to dynamic 3D models. The Stickman Animation Activity will encourage creativity and spatial understanding by allowing students to experiment with motion and animation concepts. Together, these activities will significantly contribute to making education more engaging, interactive, and widely accessible.
This project aims to make Liquid Galaxy easier to use by building a system that can automate content creation and control the screens using simple natural language commands. Currently, users need technical knowledge to create KML files, manage content, and operate the system, which makes it difficult for beginners. To solve this, I will build an AI server that runs on a Single Board Computer and acts as an assistant for Liquid Galaxy. Users will be able to give commands using chat or voice, and the system will handle tasks like generating KML visualizations, sending content to the screens, and controlling the setup. The system will be modular, so different features (like visualization, control, and communication) can be added or improved easily. It will also support both local processing and external services depending on what works best with the available hardware. This server will live on the same LAN as the liquid galaxy rig. The main deliverables include: A working AI agent server running on a Single Board Computer Chat and voice interfaces for user interaction, external services like telegram, discord, etc will also be supported. A media pipeline to generate and send KML, images, and other content to Liquid Galaxy A content builder for creating simple apps, and interactive outputs Real-time data visualization from open data sources (aircraft, satellites, disasters, etc.) Automated storytelling and guided tours based on user input (eg- historical events) News and event-based visualization on the globe A knowledge assistant using Liquid Galaxy documentation An interactive troubleshooting system for diagnosing and fixing issues User friendly instructions via .md files, to help new developers get started Agent personality customization Complete documentation, deployment scripts, and setup guides The final result will be a simple, flexible, and easy to use system that helps users and contributors interact with Liquid Galaxy.
<p>The [OpenTelemetry Go Compile Instrumentation](https://github.com/open-telemetry/opentelemetry-go-compile-instrumentation) project provides `otelc`, a compile-time auto-instrumentation tool for Go applications. It injects OpenTelemetry instrumentation during the Go build process without requiring manual source-code changes in the target application. As the project moves toward its v1.0 release and continues feature-parity work with mature compile-time instrumentation efforts such as [Orchestrion](https://github.com/DataDog/orchestrion) and [Loongsuite](https://github.com/alibaba/loongsuite-go-agent), the next phase is to broaden real-world library coverage while hardening the tooling and contributor workflow needed to maintain those integrations over time. This mentorship focuses on adding several mentor-approved integrations from the project roadmap and backlog, such as messaging, database/cache, logging, Kubernetes client, or GenAI SDK libraries, while improving `otelc` whenever the integration work exposes gaps in rule authoring, hook implementation, testing, or debugging. The mentee will also document the science behind compile-time instrumentation: how Go symbols and versions are matched, how hooks are injected, how OpenTelemetry semantic conventions are applied, and how compatibility is verified across library releases.</p><p><br></p><p>Expected Outcome:</p><p> - Add `otelc` instrumentation support for 3-4 widely used Go libraries selected with mentors from the project roadmap/backlog, depending on complexity and project priorities.</p><p> - For each new integration, implement instrumentation rules and hook code, define supported version ranges, and follow the relevant OpenTelemetry semantic conventions.</p><p> - Add meaningful unit, integration, and/or end-to-end tests that verify the instrumented application builds and emits the expected telemetry.</p><p> - Improve the instrumentation tooling or contributor workflow as needed during the work, for example rule validation, hook scaffolding, latest-library compatibility checks, integration layout, or debugging output.</p><p> - Write documentation, examples, and demos that explain how to use the new integrations and how future contributors can build similar ones.</p><p><br></p>
<p>Kuadrant's MCP Gateway is an Envoy-based gateway for Model Context Protocol (MCP) servers. It currently handles authentication and coarse-grained authorization via AuthPolicy/Authorino, but has no built-in mechanism for tool-level authorization, e.g., allowing agent A to call `add` and `subtract` on a math server while agent B can only call `subtract`. The kube-agentic-networking SIG is defining a standard AccessPolicy CRD for exactly this. MCP Gateway is well-positioned to implement it because its ext_proc already parses MCP request bodies and exposes tool metadata via headers (`x-mcp-method`, `x-mcp-toolname`, `x-mcp-servername`). This project will design how AccessPolicy maps to Kuadrant's AuthPolicy/Authorino, then build an experimental implementation covering CRD definition, a controller that translates tool-level authorization rules into Authorino configuration, identity model integration (starting with OIDC), `tools/list` response filtering so callers only see tools they're authorized to use, and CEL-based authorization expressions. The mentee will work closely with mentors on the design doc, pair on implementation decisions, and engage with both the Kuadrant and kube-agentic-networking communities.</p><p>- Expected Outcome:</p><p> - Design document covering AccessPolicy-to-AuthPolicy/Authorino mapping, body parsing strategy (ext_proc vs Envoy MCP filter), identity model choices, `tools/list` filtering, and CEL-based authorization</p><p> - AccessPolicy CRD with status conditions and CEL validation rules</p><p> - Controller that watches AccessPolicy resources and generates/updates AuthPolicy resources with authorization rules based on `x-mcp-toolname` headers</p><p> - OIDC identity source support, with consideration for ServiceAccount and SPIFFE identity types</p><p> - `tools/list` response filtering so callers only see tools they are authorized to invoke</p><p> - CEL-based authorization rule support (e.g., `request.mcp.tool_name.startsWith("read_")`)</p><p> - E2E tests covering allow/deny scenarios for tool-level access control</p><p> - Documentation guide in `docs/guides/`</p><p><br></p>
<p>On the Kyverno website, we want to introduce and document a set of technical outcomes that users can achieve by adopting Kyverno. These outcomes should group together Kyverno’s policy capabilities (validate, mutate, generate, verify images, cleanup) into clear, high-level goals that resonate with platform engineers, security teams, and developers.</p><p><br></p><p>Rather than focusing on individual features, this work will highlight what teams can accomplish with Kyverno in real-world environments.</p><p><br></p><p>Proposed technical outcomes include:</p><p>* Secure-by-Default Kubernetes – Enforce security and compliance policies across clusters automatically</p><p>* Policy-Driven Platform Engineering – Enable golden paths and self-service infrastructure using policy as code</p><p>* Automated Governance & Compliance – Continuously audit, report, and enforce organizational standards</p><p>* Software Supply Chain Security – Verify images, enforce provenance, and reduce risk in CI/CD pipelines</p><p>* Kubernetes Configuration Automation – Use mutation and generation to reduce manual configuration overhead</p><p>* Multi-Cluster Policy Management – Apply consistent governance across distributed and multi-cloud environments</p><p>* AI & Agent Governance – Apply policy controls to AI workloads and agent-driven infrastructure workflows</p><p><br></p><p>Each outcome should connect Kyverno capabilities to real-world use cases, supported by artifacts from the community such as blog posts, talks, policy examples, and reference architectures.</p><p><br></p><p>Expected Outcome:</p><p> * A new section of the Kyverno website dedicated to Technical Outcomes, where each outcome includes:</p><p> * A clear description of the problem space and desired outcome</p><p> * Mapping to Kyverno capabilities and policy types</p><p> * Links to supporting resources (blogs, videos, talks, GitHub examples, policy libraries)</p><p> * Optional diagrams or visual flows illustrating how Kyverno enables the outcome</p><p><br></p><p>This section should serve as:</p><p>* A learning and onboarding resource for new users</p><p>* A messaging bridge between technical features and business value</p><p>* A foundation for future content, including case studies, solution briefs, and AI-driven policy generation experiences</p><p><br></p>
<p>Hyperledger Cello is an enterprise-grade Blockchain-as-a-Service (BaaS) platform that provides a comprehensive REST API for managing the full lifecycle of Hyperledger Fabric networks (Network, Node, Channel, Chaincode). However, all current operations require users to interact manually through the Dashboard, which presents a steep learning curve for newcomers.</p><p><br></p><p>This project aims to implement an AI-powered operation agent with chatbot interface for Hyperledger Cello. It consists of two components:</p><p><br></p><ol><li>AI Agent Backend: A Python service that wraps Cello's existing REST APIs into LLM. It accepts natural language requests, invokes Cello operations, and returns structured responses. It also provides AI-assisted fault log summarization for common Fabric failures.</li><li>Chatbot UI — A chatbot interface integrated into Cello's existing Dashboard (React), allowing users to interact with the AI agent.</li></ol><p><br></p><p>The combined system enables a natural language-driven operational workflow:</p><p><br></p><p>User (chat message) → Chatbot UI → AI Agent → Cello REST API → Fabric Infrastructure</p><h3><br></h3><h3>Learning Objectives</h3><ul><li>Open Source Collaboration: Familiarity with Hyperledger Cello workflow, code review standards, and CI pipeline.</li><li>Full-Stack Engineering: Experience building a production-integrated feature spanning a Python backend and a React frontend.</li><li>Applied AI Engineering: Proficiency in LLM Tool Calling integration, streaming response handling, and prompt engineering.</li><li>Blockchain Infrastructure: Hands-on understanding of Hyperledger Fabric network topology, node types, and Chaincode lifecycle.</li></ul><h3><br></h3><h3>Expected Outcome and Deliverables</h3><ul><li>Deliverable: AI Agent Backend</li><li>Acceptance Criteria: Python service exposing a chat API endpoint; supports natural language execution of core Cello operations (list/create networks, manage nodes, query channels and chaincodes)</li></ul><p><br></p><ul><li>Deliverable: Chatbot UI (Dashboard)</li><li>Acceptance Criteria: Chat panel integrated into Cello's existing React Dashboard; supports streaming responses; maintains multi-turn conversation context</li></ul><p><br></p><ul><li>Deliverable: Documentation</li><li>Acceptance Criteria: Setup guide for the AI agent</li></ul>