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.
<p>Distributed tracing is essential for GenAI observability, but observing AI Agents differs fundamentally from observing microservices. While microservice traces focus on network latency and error codes, AI traces focus on the "reasoning process." The current Jaeger UI displays traces in a standard waterfall timeline, making it difficult to distinguish between logical "Tool Calls" and technical operations, and nearly impossible to read multi-paragraph prompts or view generated images. This project aims to transform the Jaeger UI into a first-class GenAI observability tool. When Jaeger detects a trace containing GenAI-specific metadata (following OpenTelemetry semantic conventions), it should automatically adapt its presentation to prioritize the "Agentic Flow."</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>Automatic "GenAI Mode" detection: detect `gen_ai.*` attributes and offer/switch to a specialized visualization mode</li><li>Agentic hierarchy with iconography: use distinct icons to differentiate span types (e.g., "brain" for LLM calls, "wrench" for tool calls, "database" for RAG retrieval)</li><li>Rich-media side panel leveraging ADR-0006 side-panel capability, with Markdown support for prompts and completions, pretty-printed JSON for tool inputs/outputs, and direct rendering of images/audio previews</li><li>Simplified "logical" view: toggle to hide infrastructure-level noise and reveal a clean, high-level reasoning flow</li><li>More compact table view of multiple traces on the Search page</li></ul>
The Shmdata library provides a layer to share streams of framed data between processes via shared memory. It supports any kind of data stream: it has been used with multichannel audio, video frames, 3D models, OSC messages, and various others types of data. Shmdata is server-less, but requires applications to link data streams using socket path (e.g. "/tmp/my-shmdata-stream"). Shmdata is very fast and allows processes to access data streams without the need for extra copies. However, permissions are not supported, and any stream shared on the system with Shmdata is accessible system-wide. The project will enable the possibility for a Shmdata user to configure streams permission using shared memory right setting at the API level. When sharing data between processes via shared memory, not all components of the data need to be visible to everyone. Different groups might need to access different data, furthermore, some data might only be needed to be visible to the owner of the files. In such cases, the permissions that would have to be implemented are combinations of 'read', 'write' and 'execute' permissions that would be given to the owner, group or common user(i.e. everyone else). Permissions would be 'none', 'execute only', 'write only', 'write and execute', 'read only', 'read and execute', 'read and write', 'read, write and execute' with corresponding values of 0-7 respectively. DELIVERABLES * Providing an option for users to restrict or openly share data streams via these file/ directory access modes: read, write and execute/traverse. * Changing data access permissions. * Documentation for the improvements made. * Incorporation of ACL to assist with Unix file permissions. (optional/if time allows).
This project aims to implement a high-performance Apache Arrow backend for PODIO. Currently, PODIO data is primarily persistent in ROOT and SIO formats, which can introduce significant I/O overhead for modern, language-independent analytics. The Problem In high-energy physics, data analysis often requires processing only specific subsets of complex event structures. Traditional file-based backends often require loading entire object hierarchies, leading to memory and I/O bottlenecks. The Solution The proposed solution implements a dual-path ingestion strategy within PODIO's code generation engine In-Memory Zero-Copy Access: Utilizing arrow::ListView to map existing PODIO memory buffers directly into Arrow tables for real-time, language-independent analysis. Serialized Normalization: Implementing a normalization layer that packs scattered memory blocks into contiguous arrow::ListArray structures to satisfy the strict requirements of Parquet storage. Relational Mapping: Resolving C++ pointers into a Composite Key (Collection ID + Index) to maintain complex object relationships across different platforms and memory layouts. Key Deliverables Core Arrow Backend: A C++ implementation integrated into PODIO's generator to translate YAML-defined models into Arrow’s columnar format. Parquet Support: Out-of-the-box serialization to industry-standard Parquet files. Round-Trip Validation: A robust testing suite ensuring 100% data parity when converting between PODIO Frames and Arrow Tables. Performance Benchmarking: A side-by-side comparison of throughput and disk footprints between ROOT TTree and the new Arrow/Parquet backend.
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.
This project implements comprehensive patient-facing digital health capabilities in the CARE platform by integrating Ayushman Bharat Digital Mission (ABDM) Personal Health Record (PHR) flows. While CARE currently supports provider-side health information exchange through the existing ABDM module, it lacks patient-centered features that would allow individuals to access and control their health data. My solution builds a complete set of APIs and interactive user interfaces to bridge this gap by implementing seven key components: ABHA Enrollment - Digital identity creation with multiple verification methods Profile Login - Secure multi-channel authentication and session management User Profile Management - Personal health information control and preferences Discovery and Linking - Finding and connecting fragmented health records Subscriptions & Notifications - Automated health updates and alerts Consent Management - Granular control over data sharing permissions Health Record Display - Unified view of medical history across providers The implementation seamlessly integrates with the existing ABDM module while adding complementary PHR capabilities, enabling CARE to function effectively in dual roles—as both a provider-focused clinical system and a patient-centered health record platform. Deliverables include a fully functional implementation of all ABDM PHR APIs, an intuitive and responsive patient portal interface, comprehensive transaction tracking for compliance, and thorough documentation. All components will adhere to healthcare security and privacy standards while providing a cohesive user experience. The completed project will transform healthcare delivery by eliminating information gaps between providers and empowering patients as active participants in their care journey.
This proposal focuses on improving the behavioral evaluation (eval) infrastructure of Gemini CLI to ensure reliable and safe AI tool usage. The current system has significant gaps, including missing eval coverage for ~37.5% of tools, a large number of non-CI-blocking (flaky) tests, and lack of tooling for debugging and contributing to evals. To address this, the proposal introduces a three-part approach: Expand and Stabilize Behavioral Evals Write 15–20 new evals covering uncovered tools and missing behaviors (error recovery, multi-step reasoning, safety, ambiguity handling). Stabilize flaky evals and promote reliable ones to CI-blocking status. Focus on testing tool-call decisions instead of text output for robustness. Enable Contributor Participation via Skills & Subagents Introduce an eval-writer skill to help generate evals. Build subagents like eval_investigator (debugging failures) and quality_analyst (coverage analysis). Make eval development accessible to open-source contributors. Fix Ecosystem Gaps (Process, Tooling, Documentation) Define clear eval review, promotion, and regression-handling processes. Improve logging with readable tool-call traces. Create the Eval Development Kit (EDK) with tools for: Eval inventory & coverage analysis Validation checks Auto-generating evals from real chat logs Add documentation, tutorials, and GitHub automation for easier community contributions. Overall, the goal is to transform evals from a limited internal system into a scalable, contributor-friendly quality framework, enabling the OSS community to actively improve AI behavior, reliability, and performance.
Keploy - OSS Code Indexer for Efficient Retrieval. (Project-2) Problem solved - Current AI models struggle to generate high-quality Unit Tests for large codebases without a deep, structured understanding of the source code. Solution Plan- 1. I implemented code parsing using tree-sitter to create semantic chunks, preserving essential context. 2. Then generating embeddings for these chunks with Gemini, openAI, huggigface and store them in a Milvus vector database. 3. I'm utilizing HNSW indexing within Milvus for efficient semantic similarity search. 4. Then I have extracted code relationships (function calls, class inheritance etc.) and store them as a knowledge graph in Neo4j. 5. Embeddings are generated with Gemini :- https://huggingface.co/spaces/mteb/leaderboard 6. I have developed a dynamic indexing mechanism (using file watching/Git hooks, potentially enhanced by Difftastic) to keep both Milvus and Neo4j synchronized with code changes. 7. Then I build a hybrid retrieval system querying both Milvus (for semantic relevance) and Neo4j (for structural context). 8. Then I integrated this combined context into Keploy's existing Unit Test Generation (UTG) workflow, feeding it to the Gemini API for test creation. 9. Then I need further suggestion to implement an LLM-as-a-judge component to evaluate the generated tests. Deliverables:- A robust GraphRAG system integrated into Keploy. This includes codebase indexing (vector embeddings in Milvus, structural graph in Neo4j), dynamic index updates, hybrid context retrieval, and integration with the Gemini, leading to substantially improved Unit Test Generation quality and relevance for users with large or complex codebases. Thanks. Regards Sparsh.
This project enhanced Stingray.jl, the Julia-based implementation of the Stingray library for X-ray timing analysis in high-energy astrophysics. Starting from my childhood passion for astronomy, GSoC allowed me to contribute to real astronomical research tools that analyze signals from stars and X-ray telescopes. Technical Journey & Contributions: Beginning with learning Julia from scratch and understanding astronomical data formats through NASA HEASARC documentation, I implemented core functionality across multiple areas: Event Data Processing: Developed comprehensive read events functionality supporting .evt and .fits files from telescopes like NICER, including GTI (Good Time Intervals) handling, energy filtering (filter_energy), and metadata extraction. This enables astronomers to process millions of X-ray events efficiently. Light Curve Analysis: Built complete lightcurve workflows from raw telescope data to scientific plots, including creation, error handling, rebinning, and intuitive plotting recipes allowing simple plot(lc) commands. Spectral Analysis: Implemented Power Spectrum and Averaged Power Spectrum analysis for both binned and unbinned data, with multiple normalization options (Leahy, fractional, absolute) and comprehensive visualization capabilities. Cross-Spectrum Analysis: Tackled the most challenging component - Cross-Spectrum and Averaged Cross-Spectrum implementation for studying phase lags and time delays between different energy bands. This contribution includes advanced plotting for amplitude, coherence, time lag, and phase lag analysis. The project transformed my understanding from basic stargazing to sophisticated astronomical data analysis, creating tools that real astronomers will use to unlock the mysteries of the universe.
Data is the new big thing for search engines in today’s time but it can be difficult for web crawlers to effectively interpret the context of the data. To deliver better search results, web crawlers need to have a context of the data and to understand the data better, structured data is used. Structured data is the data which conforms to a data model, has a well defined structure, follows a consistent order and can be easily accessed and used by a person or a computer program. It is used by search engines to generate rich snippets, which are small pieces of information that will then appear in search results making the search results more relevant. Currently Joomla! has rich snippets implemented but it uses inline microdata to implement rich snippets which is difficult to modify from the backend as it is hard coded into the html. With this project I’ll be working on to making it easier for the user to dynamically integrate structured data from the backend. For the dynamic integration of structured data I’ll be using schema.org which provides a universally recognized format for structuring data on the Web. There are different ways to implement schema markup but for this project I’ll be using JSON-LD as it can be inserted into the web page without disrupting other contents or HTML and it is easy to store in the database. This project will help user to add, update or delete schema markup on the articles from the backend. It will give user an option to select the type of schema from the available schema types and then insert values for the attributes of schema properties in the form. Some useful data which is already present in other forms will be fetched using AJAX Interface and it will be directly inserted into the JSON object. After saving the article, the generated schema will be pushed into the head element of the page.
OGC SensorThings API is an international standard to eliminate vendor lock-ins in IoT systems and to create an open geospatial ecosystem by defining a standard data model and describe how to retrieve the ingested data. However, the standard by itself does not specify a way to physically store the data. Most of the current server implementations are all based on Postgres databases using the PostGIS extension. Unfortunately, relational databases are not a great choice to store large volumes of data, which is often the case with IoT applications. As a result, retrieving large volumes of data from any of the open source SensorThings API servers is painfully slow. Modern data lakehouse standards and cloud-native geospatial file formats offer a scalable, modular, cost-effective and a much faster way to store and work with large volumes of geospatial data on the web. Specifically, Apache Iceberg is an open table format for organizing data lakes in object stores and ensuring ACID guarantees. GeoParquet is a cloud-native geospatial file encoding, based on a columnar data storage format for tabular data that significantly compresses the data and improves querying efficiency. A cloud native SensorThings API extension using Apache Iceberg could significantly enhance the standard's ability to ingest and aggregate large heterogeneous streams of sensor data. The proposal hence puts forth a design architecture for any SensorThings API server to use Iceberg to store and retrieve sensor data in a more efficient manner reducing memory overhead and network latencies when retrieving such data over the web. Eventually, as GeoParquet gets merged into Iceberg, the implementation will support a much faster alternative to existing SensorThings API implementations for handling sensor data at scale.
This solution addresses the problem that BanyanDB / BydbQL has a high usability barrier, making it difficult for users to accurately translate natural language queries into executable query statements. In real-world observability and operations scenarios, users often lack deep understanding of query syntax, schema structures, and query patterns, resulting in low efficiency and high error rates. To solve this, the proposal designs and implements an NL2BydbQL intelligent query agent. Leveraging large language models and the LangGraph reasoning framework, the agent converts natural language into executable BydbQL. The system combines RAG (grammar rules, few-shot examples, schema semantics), MCP-based real-time schema awareness, and a multi-stage reasoning pipeline to form a complete loop from intent understanding to query generation and validation. The core approach includes: Building a structured knowledge system (Grammar Rules, Few-shot Examples, Schema Semantic Docs) Designing a dual-path reasoning mechanism (QA vs. Workflow) with dynamic routing based on query complexity Introducing an intermediate representation (IR) to unify generation and repair Ensuring query correctness via parser validation and automatic repair Incorporating runtime feedback and session memory for continuous improvement The deliverables include: A production-ready NL2BydbQL agent (based on LangGraph) A set of structured RAG datasets (grammar, examples, schema descriptions) A complete and extensible reasoning workflow design End-to-end capabilities including query generation, auto-correction, clarification interaction, and execution feedback loop This solution significantly lowers the query barrier and improves the usability and efficiency of SkyWalking and BanyanDB in intelligent operations scenarios.
Problem Statement In interactive tabletop environments, Game Masters (GMs) face significant cognitive load when managing audio assets during live narration. Manually searching for and triggering specific dramatic recordings often disrupts the immersive flow of the session. There is a need for an automated system that can understand narrative intent and retrieve assets without interrupting the storytelling process.Proposed Solution I plan to bridge the gap between raw audio data and narrative utility by developing an automated pipeline for the TableTalk ecosystem. Leveraging my background in Computer Science and Economics and experience in agentic AI frameworks, I will implement:Narrative Tone Classification: Using a machine learning framework to categorize voice recordings into distinct narrative states (e.g., Urgent, Calm, Fearful).Hybrid Semantic Retrieval: Creating a retrieval engine that combines structured filtering with semantic ranking to allow GMs to use natural-language queries.Real-Time Trigger Logic: Implementing stream-based keyword spotting to map a storyteller's live performance to environmental atmospheric effects like lighting and soundscapes.DeliverablesQuantized Inference Engine: A lightweight model optimized for on-device mobile execution to ensure low-latency narrative classification.Search & Retrieval Module: A high-fidelity interface for natural-language audio discovery.Atmospheric Bridge: A software component that translates identified narrative tones or keywords into external hardware triggers.Technical Documentation: A complete guide and implementation roadmap for integrating these modules into the TableTalk mobile application.This project combines technical machine learning rigor with a deep appreciation for narrative immersion, informed by my previous work in multi-genre game development and algorithmic optimization
Current manual evaluation methods for LLM-based AI applications are unsustainable and resource-intensive. While using LLMs as judges offers a promising alternative, evaluation frameworks provide structured tools that harness LLMs for automated assessments, offering metrics, benchmarks, and scalable testing methodologies that overcome manual evaluation limitations. Gemini's integration with evaluation platforms lacks comprehensive documentation compared to providers like OpenAI and Anthropic. Analysis of ten major frameworks reveals scattered integration, decentralized documentation, and limited implementation guidance for Gemini, creating barriers for developers and researchers. I propose a three-pronged approach to improve Gemini support across evaluation frameworks. First, adding native Gemini support to select frameworks (DeepEval and TruLens) that already offer direct integrations for other providers. Second, enhancing both abstraction-layer and framework-specific documentation, covering API key management, model configuration, and multimodal capabilities. Third, creating framework-specific guides in Python and TypeScript that demonstrate effective combination of library features with Gemini APIs. For code deliverables, I will develop native Gemini integration for DeepEval and TruLens frameworks, with pull requests submitted to respective GitHub repositories. Documentation deliverables include enhanced guidance for abstraction layers (LiteLLM, LangChain, LlamaIndex) focused on Gemini configuration, and framework-specific documentation covering API management, configuration options, multimodal integration, and evaluation best practices. Tutorial deliverables will include comprehensive guides for all ten analyzed frameworks, with Python implementations for all frameworks and TypeScript for supported ones, step-by-step configuration instructions, advanced usage examples highlighting Gemini's multimodal capabilities, and error handling techniques.
I will build an accessible AI support agent for Zendalona product.. This project addresses a critical gap in accessibility support by creating a conversational interface that seamlessly accepts both voice and text input, allowing users to interact naturally with Zendalona's product ecosystem. The technical architecture employs an Agentic Retrieval-Augmented Generation (RAG) approach using LlamaIndex. This system will methodically index all Zendalona product information, documentation, and support materials in a vector database (ChromaDB or FAISS). When users submit queries, the system retrieves contextually relevant information and passes it to a large language model alongside the query, enabling precise, helpful responses based on accurate product knowledge. The implementation follows a three-tier approach: First, a comprehensive data ingestion pipeline that processes, cleans, and vectorizes Zendalona's product information. Second, a robust Python backend built with FastAPI that handles query processing, context retrieval, and response generation through integration with STT/TTS services and LLM APIs. Third, a fully accessible React-based multimodal chat interface featuring high-contrast text, complete keyboard navigation, ARIA attributes, and seamless screen reader compatibility, particularly with Orca. Key deliverables include a modular, containerized system with separate frontend and backend Docker containers orchestrated via Docker Compose, comprehensive API documentation, extensive accessibility testing results, and detailed user guides. The solution prioritizes WCAG 2.2 compliance, minimal latency, data privacy, and security throughout the architecture. The final product will provide visually impaired users with an intuitive, conversational way to access product support that works effectively with their existing assistive technologies.
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.
Modern machine learning workflows in High Energy Physics increasingly rely on large-scale datasets, where the data-loading stage can become a primary bottleneck for performance and scalability, particularly due to the lack of visibility into the I/O behavior of data-loading pipelines. While model performance is extensively studied, data ingestion remains comparatively under-characterized and often limits scalability due to inefficient access patterns, filesystem contention, and poor interaction between data formats and loading strategies. This project addresses this gap by developing a reproducible benchmarking and analysis framework for characterizing data-loading performance in ML pipelines. The system will integrate the Darshan I/O characterization tool to capture system-level access patterns and combine them with application-level metrics such as throughput and runtime. It will support multiple data formats and compare different loading approaches, including the native PyTorch DataLoader and a ROOT-based loader. The methodology consists of controlled experiments that vary data formats, loader configurations, and execution parameters. Results will be processed through an analysis layer to identify recurring patterns and bottlenecks, and a diagnostic component will detect inefficiencies and provide actionable recommendations. The main deliverables of the project are: - A modular CLI-based benchmarking system for dataset generation and ingestion, configurable experiment execution, and structured result collection. It will enable reproducible experiments across data formats (NumPy .npz, HDF5, CSV, ROOT RNTuple), loader implementations, and execution configurations. - Integration of Darshan for automated I/O profiling and trace collection - A curated set of benchmark experiments covering representative combinations of data formats, loader implementations, and configuration parameters - Documentation and a final report summarizing findings and best practices
This project addresses the challenge of distinguishing meaningful security knowledge from noisy or irrelevant changes in OWASP repositories. Currently, large volumes of repository updates include formatting changes, test files, and administrative edits, which dilute the quality of extracted knowledge and reduce the efficiency of downstream systems. To solve this, I propose building a two-stage intelligent filtering pipeline within the OpenCRE Scraper & Indexer framework. The first stage uses regex-based rule filtering to eliminate obvious noise (e.g., non-informative files and structural changes), ensuring low-cost, high-speed preprocessing. The second stage applies LLM-based semantic classification (via models like GPT-4o-mini or Gemini Flash) to determine whether a change introduces genuine security knowledge, such as new vulnerabilities, attack techniques, or mitigation strategies. This hybrid approach balances efficiency with deep contextual understanding. The system will be integrated into the OpenCRE pipeline, forwarding only relevant outputs into a knowledge queue for further processing. It will include structured logging, prompt optimization, cost-efficient API usage, and robust evaluation based on precision, recall, and accuracy. Deliverables include: 1. A production-ready two-stage filtering pipeline (regex + LLM) 2. Integration with the OpenCRE knowledge ingestion workflow 3. A labeled evaluation dataset and performance benchmarks (targeting high accuracy and recall) 4. Unit-tested, scalable, and well-documented codebase 5. Detailed documentation on prompt engineering, system design, and evaluation methodology This project will significantly improve the quality, reliability, and scalability of security knowledge extraction, enabling the OWASP community to focus on high-value insights while reducing noise in the ecosystem.
The process of identifying patients meeting certain criteria is crucial to advance research and contributes to new knowledge in medicine and health. So, data on specific populations are necessary to perform such research. However, faced with vast and complex healthcare data, traditional data analysis and processing methods prove to be inadequate.For example, cohort discovery is a popular existing tool that can allow researchers to safely explore the data in the Research Data Warehouse (RDW) prior to making a data request. But in real-world scenarios, the cohort discovery tool is not easy to use because users need to get familiarized with the workflow of the tool and it may even acquire them to write complex query languages, such as SQL. We also observe this inconvenience with the existing cohort discovery tool in D4CG, an open-source organization of the Pediatric Cancer Data Commons. As it works on building communities, platforms and becoming the critical data source for researchers and organizations, it has become evident that implementing an efficient cohort discovery tool would significantly enhance Research and Development (R&D) efficiency. With the rapid growth power of Large Language Models (LLM), this project proposes an innovative solution to enhance the cohort discovery tool by developing a query agent based on LLM to achieve more flexible and efficient data analysis and processing. To prototype this query agent, this project focuses on refining natural language understanding (NLU), improving query accuracy, supporting more complex filters, and integrating feedback mechanisms to learn from user interactions. For example, Given a user question like “Can you help me find patients aged between 20 and 40 who have a history of toothache in the Clinic Table?”, the query agent takes the question along with the corresponding database schema as input. It then generates a query output that satisfies the user’s request.
The recent efforts of the `scala-wasm` project have made it possible for Scala to use the WebAssembly Component Model binary format as a compilation target. Although, the implementation has not yet been finished, it is already possible for developers to run Scala code on Wasm runtimes. In order for the Scala language to succeed in the Wasm ecosystem, core libraries which rely on platform APIs must be ported to the Wasm/WASI platform. The goal of this project is to prototype porting the core parts of the Cats Effect and FS2 libraries to the Wasm/WASI platform. The CE runtime prototype will be single-threaded and based around `wasi:io/poll`. The end result is expected to be similar to the (now-replaced) single-threaded LLVM runtime which used a `libuv`-style event-loop. The FS2 porting effort is going to focus on `fs2-core` and the `network` and `file` APIs from `fs2-io`. As a part of this project, a standalone reimplementation of java.nio.file API will be developed as a separate library. Planned Deliverables: 1. A working prototype of Cats Effect's single-threaded runtime compiling and running on Wasm/WASI free of glue JavaScript code. This prototype will serve as a basis for an upstream implementation. 2. Prototype port of the core FS2 module and the fs2.io.file and io.network APIs. 3. A standalone library reimplementation of JDK file APIs for WASI. Initial scope of the implementation will be adjusted to the needs of the fs2.io.file port. 4 An extensive documentation of the project. 5. A report regarding implementation details and findings discovered over the course of the project which will help with further porting efforts of Scala compilers and other platform-dependent libraries. 6. Wasm test environment and CI created for this project can upstreamed to sbt-typelevel so that it can be used in other projects.
Summary: The goal of this project is to improve the Linux-Intelligent OCR Solution (LIOS), an open-source tool for text extraction from images, scanned documents, and PDFs using Tesseract and Cuneiform OCR engines. The primary focus will be on enhancing usability, accessibility, and performance, particularly for visually impaired users, while also addressing several existing issues. Problem: LIOS is a powerful tool, but there are several issues that hinder its usability and accessibility. These include problems with the UI/UX design, scanner compatibility, OCR integration, and the lack of proper error handling, which often leads to crashes. Additionally, there are several other bugs that need attention, such as issues with text focus, icon display, and preview functionality. Solution: The project will focus on addressing these issues and improving the overall user experience: UI/UX Improvements: Simplify the interface and improve accessibility, particularly for low-vision users. Bug Fixes & Code Refinements: Address the following specific issues: Text Focus: Ensure the textview regains focus after using Goto Line and Goto Page. Tab Focus: Improve tab focus handling for better navigation. Icon Display: Fix the larger icon issue in the icon view for consistent UI presentation. Print Preview: Fix the Print Preview functionality, which currently isn’t working as expected. Error Handling: Implement proper error handling to prevent crashes and unexpected behavior. Image Rotation: Resolve the automatic deletion issue when rotating selected areas of the image. Find/Replace Accessibility: Ensure the Find and Find & Replace features are fully accessible and functional. Scanner Compatibility: Improve compatibility with various scanner models, ensuring better cross-platform support. Tesseract Integration: Enhance the detection of Tesseract data paths for more accurate OCR functionality.
The proposal outlines a project to migrate the management of omegaUp's public courses to GitHub, enabling open-source contributions and improving collaboration, version control, and deployment consistency. Currently, omegaUp's public courses are managed manually, which can be time-consuming and lacks community involvement. By using GitHub, contributors can submit pull requests (PRs) to update course content, which will be automatically validated and deployed using GitHub Actions and omegaUp's API. Key components of the project include: 1. Course Migration: All public courses will be uploaded to a GitHub repository, structured by course and content type (lectures, problems, etc.). 2. CI/CD Workflow: A GitHub Actions pipeline will validate and deploy updates when a PR is merged. This pipeline will automatically check for any changes in problems and deploy only the modified content. 3. API Integration: The system will use omegaUp’s API to upload content after successful review and approval of changes. 4. Community Collaboration: Contributors can suggest improvements via PRs, with a review process ensuring quality control before deployment. 5. Automated Testing: The CI/CD pipeline will run validation scripts to check metadata, problem structure, and other course details before deployment. 6. Security: A review and approval mechanism will prevent unauthorized or malicious content from being deployed. The project aims to enhance omegaUp’s educational content by leveraging GitHub’s collaboration model, ensuring faster updates, better quality control, and reduced manual workload for omegaUp staff. A proof of concept has been set up in a sample GitHub repository, where contributors can simulate the entire workflow by submitting PRs and seeing automatic deployments on omegaUp. This approach is expected to streamline course management, making it scalable and more responsive to community-driven improvements.
<p>This project is divided into two parts, namely, building a <code>matcher.js</code> library and revamping Public Lab's <a href="https://github.com/publiclab/Leaflet.DistortableImage" target="_blank"><code>Leaflet.DistortableImage</code></a> repository, a helper module for <a href="https://github.com/publiclab/mapknitter" target="_blank"><code>Mapknitter</code></a>.</p> <p>The <code>matcher.js</code> library essentially consists of the following components.</p> <ul> <li><a href="https://github.com/publiclab/matcher-core" target="_blank"><code>matcher-core</code></a>: This module employs the <code>ORB(Oriented FAST and Rotated BRIEF)</code> algorithm to automate pattern detection using the well-known <code>FAST(Features from Accelerated Segment Test)</code> keypoint detector and the <code>BRIEF(Binary Robust Independent Elementary Features)</code> descriptor technologies, which provide appreciable performance boosts on low computational costs.</li> <li><a href="https://github.com/publiclab/matcher-cli" target="_blank"><code>matcher-cli</code></a>: A Node-based CLI utility to headlessly test custom <code>matcher-core</code> configurations, for different purposes such as testing, demonstration, debugging issues, etc, <code>matcher-cli</code> enables headless support for all of these tasks, and can easily integrate (and automate) with your choice of CI.</li> </ul> <p>This project also incorporates Public Lab's <a href="https://github.com/publiclab/Leaflet.DistortableImage" target="_blank"><code>Leaflet.DistortableImage</code></a> library overhaul for the better half of its duration. For more information, checkout <a href="https://github.com/rexagod/Leaflet.DistortableImage/commits/rexa-soc-ldi" target="_blank">this branch</a> of my fork of the same repository.</p>
CircuitVerse provides a powerful digital logic simulator, but its classroom workflow lacks critical features required for effective teaching at scale. Currently, instructors cannot organize students into structured teams, assign collaborative work, reuse pre-built circuit templates, or rely on modern LMS integrations due to outdated LTI 1.1 support. These limitations lead to inefficient grading, repeated manual setup, and poor integration with platforms like Canvas. This project aims to enhance CircuitVerse’s classroom ecosystem by introducing four key improvements. First, a subgroup system will enable instructors to divide students into teams with defined roles, supporting structured collaboration. Second, group-based assignment workflows will allow submissions on behalf of a team, ensuring consistent grading and reducing redundancy. Third, a circuit template library with integrated test cases will enable reusable, pre-configured assignments and automated grading using a simulation-based evaluation pipeline. Finally, the project will upgrade LMS integration by implementing LTI 1.3 using OpenID Connect and OAuth 2.0, enabling secure authentication, deep linking, and modern grade passback via Assignment and Grade Services (AGS). The deliverables include: A fully functional subgroup and team management system with API support Group assignment workflows with submit-on-behalf functionality A template library with auto-grading using simulation-based test cases Complete LTI 1.3 integration including OIDC login, deep linking, AGS score submission, and NRPS roster access Comprehensive RSpec test coverage and documentation By addressing these gaps, this project will transform CircuitVerse into a scalable, LMS-integrated teaching platform capable of supporting modern classroom workflows and institutional requirements
<p>Kuadrant's MCP Gateway is an Envoy-based gateway for Model Context Protocol (MCP) servers that provides routing, policy enforcement, and tool federation. As the agentic ecosystem grows, we're looking to extend the gateway's capabilities beyond MCP to support other agentic protocols. The A2A (Agent-to-Agent) protocol is an emerging standard for inter-agent communication with capabilities like long-running tasks, streaming, and agent discovery via agent cards. This project will investigate how A2A support can be added to the gateway alongside MCP, then build a proof-of-concept demonstrating federated agent discovery and A2A request routing through the gateway. The mentee will work closely with mentors throughout — collaborating on the design doc, pairing on implementation decisions, and spiking on specific pieces as needed to validate assumptions early. They will also engage with the broader Kuadrant community through PR reviews, design discussions, and community calls.</p><p>- Expected Outcome:</p><p> - Analysis of the A2A protocol with a gap assessment comparing A2A and MCP traffic patterns (request/response vs long-running tasks, push notifications, multi-modal artifacts)</p><p> - Design document covering A2A routing through ext_proc, federated agent card serving in the broker, session handling implications, and CRD design</p><p> - Federated agent card endpoint in the broker that aggregates upstream A2A agent cards</p><p> - A2A request routing through the Envoy ext_proc path, with appropriate header handling and policy enforcement</p><p> - CRD design (new resource or MCPServerRegistration extension) for registering A2A agents with the gateway controller</p><p> - E2E tests demonstrating A2A agent discovery and task execution through the gateway</p><p><br></p>