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.
Modern cloud environments frequently rely on oversubscription to maximize resource utilization, which introduces significant performance challenges for OpenMP applications running inside virtual machines. In such environments, a semantic gap exists between the guest scheduler (which assumes full CPU availability) and the host scheduler (which may preempt virtual CPUs). This project proposes a set of optimizations to the GNU OpenMP runtime (libgomp) that leverage host-side scheduling information to guide execution decisions inside the guest. The core idea is to bridge the host–guest semantic gap using a low-latency shared-memory communication mechanism based \section*{Project Summary}on eBPF and ivshmem, enabling real-time propagation of scheduling metrics without incurring VM-exit overhead. A key component of the project is the implementation of a Phantom Tracker using eBPF, which monitors virtual CPU states on the host and computes a phantom average metric representing scheduling contention. This information is communicated to the guest and used to dynamically adapt two critical aspects of OpenMP execution: the Degree of Parallelism (DoP) and barrier synchronization behavior. To integrate these optimizations, the project extends libgomp with two new environment variables: GOMP_DYNAMIC_POLICY for scheduler-guided parallelism adaptation, and GOMP_WAIT_POLICY for adaptive spin–block synchronization. These enhancements allow OpenMP applications to respond to real-time host conditions, improving performance and resource efficiency under oversubscribed workloads.
Problem to Solve : Build a system which performs the following: Enables full-text search of documents; filtered by agency, date, views Recommends similar documents based on semantic similarity of document contents Extracts significant document features such as topics, persons, locations, etc. Clusters and sorts documents by artifact topic (i.e. aerospace, environmental, nuclear, civil rights, etc.) Including: Natural language summaries for each artifact in the collection. Solution: To build the requested system, we will need several components and technologies. Here are the basic steps to achieve the functionality we require: Data ingestion: Loading the documents from a data source and extract the relevant information such as the document ID, title, content, agency, date, and views. Full-text search: Indexing the documents in a search engine such as Elasticsearch and enable full-text search with filters on agency, date, and views. Semantic similarity: Using a natural language processing model such as Doc2Vec to calculate the semantic similarity between documents and recommend similar documents. Document feature extraction: Using a named entity recognition model such as Spacy to extract significant document features such as topics, persons, locations, etc. Clustering and sorting: Using a clustering algorithm such as KMeans to group the documents into clusters based on artifact topic and sort them accordingly. Natural language summaries: we can use a summarization algorithm such as Gensim to generate natural language summaries for each document in the collection.
Financial factor investing relies on rigorous quantitative research to explain asset returns and generate alpha. While many academic models and institutional frameworks exist, open-source tools that replicate these methods — especially in R — are few and far between. This project aims to close that gap by contributing to the ExpectedReturns package, developing clean, modular functions that implement and generalize key factor construction techniques inspired by Antti Ilmanen’s Investing Amid Low Expected Returns. The focus will be on engineering reusable code for factors like value, momentum, profitability, and investment using raw or semi-structured financial data. These will be built using lightweight, testable components supported by packages like FactorAnalytics, PerformanceAnalytics, and tinytest, while following conventions used by Chen, Zimmermann, and Kelly. Also included will be vignettes and documentation that show how to reproduce these concepts in practice — making the tools both transparent and portable. This will be a two-month project. Deliverables will include: – Core functions for factor construction and data prep – Lightweight unit tests and clean vignettes – Documentation of inputs, outputs, and assumptions – A reproducible build setup that works across systems The goal is to make these concepts accessible — not just for researchers, but for anyone trying to understand and apply factor models in real-world contexts. If successful, this project will leave behind a set of tools that are as useful to the open-source community as they are to academic replication.
During GSoC, I propose to build a carbon-aware fitness tracker application from scratch that combines personal health tracking with environmental awareness while prioritizing user privacy. The project addresses two key problems: the lack of privacy in existing fitness apps, which often rely on external servers, and the absence of tools that help users understand their daily carbon footprint. To solve this, I will develop a Flutter-based mobile application along with a Wear OS companion app, integrating them using the Data Layer API and platform channels to seamlessly transfer fitness data such as steps, heart rate, and activity metrics from the watch to the phone. On the Wear OS side, I will use the Health Services API to collect real-time data, while the mobile app will feature a transport logging system that calculates carbon emissions or savings based on user travel choices, along with a dashboard displaying weekly summaries, visual charts, and actionable sustainability suggestions. All user data will be stored locally using SQLite to ensure complete privacy, and the application will be supported by comprehensive unit, widget, and integration testing to ensure reliability. The final deliverables will include a fully functional mobile and Wear OS application, a secure local data management system, a carbon footprint tracking and visualization module, and a production-ready app prepared for deployment on Android and Wear OS platforms.
<p>Environments are a crucial component of <a href="https://en.wikipedia.org/wiki/Reinforcement_learning" target="_blank">reinforcement learning (RL)</a>. Grid worlds are a broad class of tile-based games that are easy to create, and are quite popular for testing and comparing various RL algorithms. They are highly versatile and provide immense flexibility in terms of creating custom environments that can test for specific properties like safe exploration, for example. <a href="https://github.com/JuliaReinforcementLearning/GridWorlds.jl" target="_blank">GridWorlds.jl</a> is a <a href="https://julialang.org/" target="_blank">Julia</a> package that provides a suite of grid world environments along with useful primitives that aid in creating custom environments.</p> <p>This project redesigns GridWorlds.jl in a way that makes it simpler, easy to understand, and more performant (in some cases) than the previous version (v0.4.0). The new version (v0.5.0) also decouples itself significantly from the API of <a href="https://github.com/JuliaReinforcementLearning/ReinforcementLearning.jl" target="_blank">ReinforcementLearning.jl</a>, which makes it easy to create entry points from other reinforcement learning frameworks. It also becomes possible to programmatically record, replay, and analyze an agent’s behavior at any point during training, which proves handy while performing reinforcement learning experiments. Moreover, one can directly play the games from GridWorlds.jl inside the Julia REPL.</p>
Open Food Facts (OFF) relies on contributions from a global community of developers and volunteers. However, setting up development environments, navigating complex CI/CD pipelines, and contributing to multiple repositories like off-server, robotoff, and smooth-app can be time-consuming and frustrating—especially for newcomers. This project aims to streamline the entire contributor journey by creating a unified, cloud-powered Developer Experience (DevX) platform for OFF.\n \n We will implement pre-configured Google IDX, Gitpod and Codespaces environments, enabling contributors to start coding within minutes. The CI/CD pipelines will be optimized to run only affected modules, significantly cutting build and test times. We'll also create a live, versioned documentation pipeline, integrate AI-powered tools for issue triage and PR review, and develop a metrics dashboard for maintainers to track workflow efficiency.\n \n Deliverables include: \n - Deployment staging environment with Docker swarm or Ansible.\n - Auto-launch Gitpod/ Codespace environments. \n - Optimized CI/CD workflows with modular test execution. \n - Automated documentation site using OpenAPI Spec + MDX + Fumadocs. \n - AI bot integration for issue triage. \n - A real-time DevX dashboard. \n \n This project will empower contributors to go from zero to green PRs faster, making OFF development more accessible, efficient, and scalable.
Dear Sir, I hope you are doing well. My name is Tianyou Liu, and I am writing to submit my GSoC 2026 proposal for Mogan STEM: “Julia Plugin with Virtual Environment Support.” In the proposal, I describe an implementation plan to enable Julia-powered, reproducible computing directly inside Mogan. The key technical components include: Mogan-side Julia plugin to identify and extract Julia code sections and provide an in-editor execution workflow. A persistent local Julia kernel process to execute code on demand and maintain session state across runs. A lightweight IPC layer between Mogan and the kernel (socket-based, request/response), returning structured execution results for rendering. Output and error capture (stdout/stderr, stack traces, and rich results where applicable) to present execution feedback clearly inside Mogan. Project-aware environment activation by automatically locating the nearest Project.toml (and using Manifest.toml when present) and executing code in the corresponding Julia environment. Integration with Julia’s Pkg workflows to support reproducible dependency management (e.g., activate/instantiate and related environment operations). My resume is enclosed in the attachment. More details are discussed in the proposal enclosed in the attachement. Thank you for your time and consideration. I look forward to the possibility of contributing to Mogan STEM this summer. Best regards, Tianyou Liu Email: liuty2025@mail.sustech.edu.cn GitHub: https://github.com/AXeonV
<p>Software Package Data Exchange (SPDX) is “a set of standards for communicating the components, licenses, and copyrights associated with software”. You can find the latest (as well as the previous) standards at:</p> <p><a href="https://spdx.org/specifications" target="_blank">https://spdx.org/specifications</a></p> <p>One idea is to accompany software with special files that hold certain meta information: authorship, copyrights, licenses, etc. These files currently come in two major formats: TAG and RDF. There are parsing tools available for these formats in Python and Go:</p> <p><a href="https://github.com/spdx/tools-python" target="_blank">https://github.com/spdx/tools-python</a></p> <p><a href="https://github.com/spdx/tools-go" target="_blank">https://github.com/spdx/tools-go</a></p> <p>These tools do not support the latest SPDX-2.1 standard (instead, they can handle SPDX-1.2) which makes it logical to add support for the latest standard.</p> <p>However, personally I am not happy with the specification which is why I would rather develop an online validation tool with the <a href="https://github.com/nexB/license-expression" target="_blank">license-expression</a> [pyLE] library which heavily relies on the <a href="https://github.com/bastikr/boolean.py" target="_blank">boolean.py</a> library [BP].</p>
This project aims to implement full coarray support in the LFortran compiler, enabling native parallel programming capabilities based on the Partitioned Global Address Space (PGAS) model defined in the Fortran 2008/2018 standards. Currently, while LFortran’s parser supports coarray syntax, the feature is not implemented beyond basic stubs, preventing execution of even minimal coarray programs. The project will bridge this gap by extending LFortran’s Abstract Semantic Representation (ASR) to model coarrays, implementing semantic analysis for coarray constructs, and introducing a dedicated coarray runtime library. A key component is an ASR-to-ASR lowering pass that translates high-level coarray operations (such as coindexed access, synchronization, and collective intrinsics) into runtime calls. This design follows LFortran’s existing OpenMP architecture, ensuring backend-agnostic support across LLVM, C, and other targets. The implementation will proceed in two phases: first, establishing a fully functional single-image mode with correct semantics and runtime integration; second, enabling multi-image execution using an MPI-based runtime backend. By the end of the project, LFortran will be capable of compiling and executing coarray programs in both single-node and distributed environments. This work lays the foundation for supporting real-world coarray-based HPC applications and positions LFortran as a leading LLVM-based Fortran compiler with modern parallel programming support.
Security-sensitive workloads on embedded and server platforms require isolation primitives to support many use cases that require enforcement of confidentiality and integrity for workload against software and hardware adversaries. Providing these protection properties requires architectural support for page-based physical memory isolation managed at the machine level to be able to create isolated supervisor domains which can then host isolated S/H and (V)U, V(S) mode software. A supervisor domain can extend the trusted computing base (TCB) to host isolated VMs and/or applications. The Supervisor domains task group has defined privileged ISA extensions (Smsdid, Smmtt, Smsdia, Smsedbg etc.), to be used by machine mode to isolate physical memory, and other platform resources flexibly across supervisor domains. As specified in the RISC-V Supervisor Domains specification, per-hart controls for a supervisor domain identifier can be used to program a memory tracking table (MTT) structure that will specify if a supervisor domain is allowed to access physical memory regions (at architectural page-size granularities). The MTT will be programmed by an M-mode root-domain security manager (RDSM). The mentee will primarily focus on developing extensions to Qemu to emulate the RISC-V Supervisor Domain (Smmtt) ISA extensions, and build an priv. software prototype for the M-mode RDSM using OpenSBI to demonstrate the functionality of the emulated ISA.
This project evaluates large language models on frontend coding and UI generation tasks by extending and integrating ideas from open-source coding benchmarks such as Multi-SWE-bench and WebDev Arena. The evaluation framework assesses coding and UI generation capabilities across various dimensions, with particular emphasis on multimodal features for frontend development. It leverages the models’ ability to generate, render, and iteratively refine solutions using visual feedback from rendered UIs, and supports multiple frontend frameworks (React, Vue, Angular, Svelte, Next.js) alongside single-file HTML tasks. The solution involves building a modular pipeline with typed configuration, provider adapters (Ollama, vLLM, OpenRouter), and a model manager; implementing multimodal evaluation loops that incorporate screenshots and structured judging; supporting iterative evaluation (allowing models to refine solutions over multiple attempts); expanding the task taxonomy with increasingly complex frontend challenges (calculators, dashboards, interactive apps, framework-based projects); and automating the entire evaluation pipeline with reproducible runs and detailed artifact logging. Deliverables include the enhanced evaluation framework with new benchmark tasks, structured outputs and reports (JSON, screenshots, summaries), automation scripts for reproducible runs, and thorough documentation. The framework provides a transparent and extensible way to compare advanced AI coding capabilities in frontend development without relying on a leaderboard, focusing instead on rigorous, reproducible benchmarking.
WebAssembly has become extremely popular among the developer community lately. It offers near native performance in a browser and is meant to not be a hand written language but to be the compilation target of source languages like C, C++, Rust etc. It provides a way to run code written in multiple languages on the web at near-native speed, with client apps running on the web that previously couldn't have done so. It, being a new language , does not enjoy wide support across platforms. The prospect of having a unified interface for web developers has long been elusive. It has the potential to provide the basis on which many apps can be built and deployed for a huge range of devices from IoT devices to fully fledged servers. But to enable developers to use it we need a WASI runtime ecosystem to support them. WasmEdge is one such project that aims to bring WebAssembly to the edge. To provide a unified interface accross multiple platforms, a interface between WasmEdge and the host operating system has to be built. This interface is specific to the platform on which the runtime is deployed and has to be built individually and specifically for each platform bearing in mind the features available. The native API provided by the OS should be used to implement many of the common operations like file manipulation, IO etc. These 'host functions' are crucial for the project to succeed and have been defined in WASI - the Web Assembly System Interface which is a modular collection of standardised APIs Currently, host specific functions have not been implemented in WasmEdge, for the windows platform. These functions are supposed to be implemented using the Win32 API and have to go rigorous testing before being deployed.
This program pairs one or more mentees with an experienced mentor to deliver an AOSP 12 emulator for 64-bit RISC-V. RISC-V International has setup Android SIG and released RISC-V Android github repo as https://github.com/riscv-android-src. Current RVI Android codebase is based on AOSP 10, while the latest AOSP is 12 now. We hope to catch up with latest AOSP 12 codebase, and as part of our plan, an emulator is required first as test and run environment. Deliverables (bullet list of components and the changes expected): - Add RISC-V target in the emulator. - Porting Ranchu virtual board to support RISC-V machine. - Corresponding unit tests implementation - Regression tests pass Note: upon work should be based on AOSP 12. 3. acceptance criteria Acceptance criteria (bullet list with measurable results defined): - Phase I: Virtual peripherals of emulator can work with RISC-V 64bit cores and pass unit tests. - Phase II: Emulator can boot-up with Linux plus basic rootfs w/o GUI for AOSP 12. - Phase III: Emulator can boot-up with Linux plus rootfs w/ GUI for AOSP 12. Note: due to AOSP 12 rootfs is still in developing, a AOSP 10 rootfs from Android SIG repo can be used instead to help verification, but the kernel version should be matched with AOSP 12.
FinBot CTF is OWASP's premier learning environment for agentic AI security, yet it currently operates solely as an offensive arena. Practitioners can exploit vulnerabilities but lack the capability to implement, test, and score defenses against the OWASP Agentic Top 10. This project closes the blue-team loop by introducing a production-inspired, hook-based security framework. The solution is a four-part architecture: (A) a pluggable Guardrail & Detection Framework with pre-tool, post-output, and pre-action hooks that emit a standardized security event model; (B) a Defense-Enabled Challenge Pack converting 3-5 existing offensive challenges (A2: Excessive Agency, A3: Memory Poisoning, A8: System Prompt Leakage) into paired red/blue tracks with integrated defensive scoring; (C) an MCP-Style Scenario Module featuring benign and malicious JSON-RPC tool servers, with detectors for output poisoning, prompt injection via payload, and unauthorized endpoint redirects; and (D) comprehensive Documentation & CI including Docker Compose, contributor guides, and a GitHub Actions test suite. This work transforms FinBot into a complete AI security training platform. Leveraging my prior contributions to the codebase, I will deliver a low-risk, high-impact implementation that equips defenders to build, test, and validate guardrails against real-world agentic threats, solidifying FinBot's role as the practical counterpart to the OWASP Agentic Top 10.
Currently, two major languages are used in high-energy physics (HEP): C++ for numerically intensive code, where execution speed is critical, and Python for interactivity and simplicity of development (frequently used as 'glue' between high-performance code modules). Julia has recently sparked increased attention as a potential language for HEP. This could provide Python's convenient features while maintaining C++'s ideal computational efficiency. In order to continue this investigation, this project will interface the data model library PODIO with Julia. This will allow you to read existing data files into a Julia program. This project seeks to use the same YAML-syntax to auto-generate Julia code for the end user to be utilized in HEP, as well as to do performance testing to compare the language interfaces for C++ and Julia. General Plan PODIO can already : Read YAML files and validate and parse them to extract necessary information like data members, relations and vector members of components and form MemberVariable objects from that information, forming a object dictionary to be used by the jinja2 template engine (using templates for C++) to generate C++ code. Our Plan: Build a prototype without code generation to test whether the current info passed to the jinja2 template Engine by the ClassGenerator class is sufficient, Accordingly adding the pre-processing logic required to the ClassGenerator class create new templates and dictionaries for jinja2 to generate Julia code. Running tests on the Julia code and refactoring generator code. Benchmarking and Documentation.
<p>Aim of the project is to improve and enhance <strong>Open Event Android</strong> project by adding more features, improving performance and fixing bugs.</p> <ul> <li>Add support for new API (<strong>JSONAPI</strong>) of Open Event API Server</li> <li>Add <strong>User Authentication</strong> in the App along with adding an option in the generator to add authentication in the App.</li> <li>Add <strong>User profile</strong> feature using which user can update name and avatar</li> <li>Improve <strong>Map</strong> by adding markers for all the microlocations</li> <li>Improve <strong>searching/filtering performance</strong> all over the App</li> <li>Add feature to <strong>cache thumbnails and images</strong> to load it when device is offline</li> <li>Add <strong>TextDrawable</strong> to show as placeholder for speaker image while image is downloading</li> <li>Enhance UI by adding <strong>Sticky Headers</strong> for grouping through out the App</li> <li>Improve UI by adding <strong>number of sessions label</strong> for track</li> <li>Improve code base to <strong>support older devices(pre-lollipop)</strong> with API level < 21</li> <li>Refactor code base to <strong>improve performance</strong> and to reuse code using Utility methods</li> <li>Fix other <strong>critical bugs</strong> and issues</li> </ul>
Deploying a honeypot is only half the battle; the real value lies in the intelligence we can extract from it. Currently, standard honeypot deployments leave valuable attacker logs isolated on individual virtual machines. If an instance is terminated, that threat data is gone forever, making it impossible to correlate global attack patterns or build a cohesive defensive strategy. This proposal shifts the C2SI Honeynet from a collection of isolated servers into a centralized, serverless Threat Intelligence Platform. Using Terraform and Ansible, I will build a modular framework to deploy secure, Dockerized sensor nodes across multiple cloud providers (AWS and GCP). Instead of logging locally, these edge nodes will use Fluent Bit to stream attacker telemetry in real-time to a centralized AWS S3 data lake. From there, an event-driven Python Lambda function will automatically enrich attacker IPs with global threat scores and geolocation data, making the raw attacks instantly queryable for researchers via Amazon Athena. I am not starting this project from scratch. To prove this architecture is viable and cost-effective, I have already engineered the core serverless pipeline, secured the remote Terraform state with DynamoDB locking, and built the hardened GCP modules in my preliminary Pull Requests (PR #8, #13, #14, #15, #35). Over the 350-hour GSoC period, my goal is to scale this proven foundation into a production-ready system that allows C2SI security teams to deploy a global honeynet and hunt threats with a single command.
The current state of the asynchronous I/O on the JVM involves using separate selector threads to manage I/O events through system functions like epoll or kqueue. Although frameworks like Netty and NIO2 make this approach seem reasonable, the use of separate event loop threads is not without cost. In high-RPS services, these threads can compete for CPU time with worker threads executing application tasks, leading to resource contention and potentially significant performance loss. In contrast, Cats Effect offers a different threading model, integrating I/O and application tasks into a single runtime system, reducing contention an enhancing overall efficiency. io_uring, the key component of this project, offers two major advantages: (1) it enables all supported syscalls to become asynchronous from the application’s perspective, allowing for multiple syscalls to be initiated in parallel without blocking the calling thread, and (2) it uses a pair of ring buffers for syscall submission and completion events that are shared between the application and the kernel, dramatically reducing the overhead of calling from userspace into kernelspace. When integrated with Cats Effect, io_uring can significantly improve the efficiency of syscalls, requiring fewer calls into kernelspace during the worker loop. This proposal brings two key innovations together: a new threading model and a new I/O API. By integrating Cats Effects and FS2 with io_uring, we aim to develop an alternative solution to minimize the inefficiencies found in the traditional model, offering a more efficient and performant solution for I/O-intensive applications.
The BeamVision extension revolutionizes interactive pipeline development in JupyterLab by transforming fragmented notebook visualizations into an integrated workspace, as envisioned in the original design document. At its core lies a dynamic side panel that fundamentally reimagines how users inspect Apache Beam pipelines - consolidating previously scattered visualizations while preserving the documented backward compatibility requirements. This architectural shift directly addresses the project's stated pain points of vertical space consumption and redundant JavaScript code by implementing the described collapsible interface and centralized rendering system. The solution carefully balances innovation with technical constraints through a hybrid approach combining kernel-side HTML generation for reliability with frontend D3.js rendering for interactivity, both explicitly prioritized in the project's technical specifications. Beyond basic visualization, the implementation delivers on the documented cluster management capabilities, providing seamless Flink/Dataproc integration exactly as outlined in the side panel use cases. Every component maintains strict adherence to the original vision - from the multi-tab comparison interface described in the design workflow to the incremental data loading strategy for large datasets. By systematically executing the documented requirements without introducing unsupported features, BeamVision transforms the proposal's vision of "better UX when exploring pipeline states" into a production-ready reality while laying foundations for future extensibility through the approved plugin architecture. The result is a purpose-built environment that finally unlocks Apache Beam's full potential within JupyterLab, precisely as the project architects intended.
<p>Kthena Router is the LLM routing component in the Volcano/Kthena project, responsible for forwarding inference requests to in-cluster and (soon) third-party model backends. As Kthena gradually matures, the community needs a reproducible benchmark to understand the router's performance characteristics (throughput, latency, tail latency, resource usage) under realistic LLM traffic patterns, and to detect regressions across releases. This project asks the mentee to design and implement a benchmark framework for Kthena Router, produce a complete report. Where the benchmark surfaces clear bottlenecks or inefficiencies, the mentee will also work with maintainers to land code-level optimizations upstream.</p><p><br></p><p>Expected Outcome:</p><p> - A reusable benchmark framework for Kthena Router (load generator, scenario configs, metrics collection, result aggregation), runnable locally and in CI.</p><p> - A defined set of test scenarios covering typical LLM routing patterns (varying QPS, prompt/response sizes, concurrency, number of backends, routing strategies).</p><p> - End-to-end test procedure documented as a runbook (cluster setup, mock/real backends, how to run, how to interpret results).</p><p> - A benchmark report with metrics (throughput, TPOT, TTFT, GPU/CPU/memory) and analysis of bottlenecks.</p><p> - Upstream PR(s) implementing optimizations for any clear hotspots identified, with before/after numbers.</p><p><br></p>
This project will enhance FOSSology's license intelligence stack by revamping both Nirjas and Atarashi into a faster, ML-driven, and language-aware pipeline. Nirjas will move from regex-oriented parsing to a Tree-sitter architecture with language packs across 248 languages, improving comment extraction fidelity in real repositories. Atarashi will be upgraded from broad full-file matching toward retrieval-plus-classification that emphasizes high-signal fragments, because keywords matter for license intent (for example, phrases like permission grant, redistribution, warranty disclaimer, copyleft, and patent terms are often decisive). To support both components, I have already upgraded the Minerva dataset pipeline to generate train/validation/test datasets for Nirjas and Atarashi using merged inputs from ScanCode LicenseDB, FOSSology licenseRef.json endpoint, and The Stack Smol comment corpus, followed by augmentation, LLM-generated hard-negative synthesis, and near-dedup. A sample dataset for benchmarking and integration testing is ready, while the full-scale dataset build is in progress. For modeling, Nirjas will use a model2vec classifier distilled from strong sentence-transformer teachers selected using MTEB/RTEB task performance together with our internal evaluations; the same model2vec distillation path is also planned for Atarashi, with a fine-tuned quantized embedding baseline retained as a fallback depending on speed/accuracy trade-offs. The expected outcome is a production-ready path to more accurate, scalable, and maintainable license detection across diverse codebases.
Drasi is a Data Change Processing platform that enables developers to detect and react to meaningful data changes using declarative Cypher queries. Drasi excels at complex change detection with unique features like `drasi.trueFor()` (detecting conditions that persist over time) and absence-of-change detection (alerting when expected events don't occur). However, it currently lacks native connectivity to IoT protocols. Drasi Lib provides Drasi's powerful graph-aware decision engine as an embeddable Rust library that can run completely offline on constrained hardware—enabling edge computing scenarios where logic runs directly on sensors and gateways. IoT applications fundamentally need to detect state transitions, but developers typically must write boilerplate code and manage state persistence manually. Drasi's diff-engine handles state management and change computation automatically, emitting events only when meaningful changes occur. MQTT (Message Queuing Telemetry Transport) is the de-facto standard protocol for IoT, used by AWS IoT Core, Azure IoT Hub, and virtually every IoT deployment. Adding MQTT support to Drasi Lib will unlock the entire IoT ecosystem for Drasi users. In this project, the mentee will build a suite of lightweight Rust crates that enable Drasi Lib to communicate with MQTT brokers. They will create connectors to ingest sensor data (MQTT Source), execute local actions (Shell Reaction), and close the control loop (MQTT Reaction).
<p>The goal of the project would be to add support for PSIMI-TAB format to the admin tools of the DV-IMPACT database and allow the upload and download of PPI network data in the same format. Currently, the data upload can only be performed by the database admin. The objective is to create registration and user profile system that allows users to register and upload their own data independently without the need of the database admin to be involved in the upload process.</p> <p>The summarized goals would be:</p> <ol> <li>Create registration and user profile system that allows users to register and upload their own data independently.</li> <li>Add support for PSIMI-TAB format to the admin tools of the DV-IMPACT database.</li> <li>Add download PPI networks in PSIMI-TAB format to the frontend of DV-IMPACT database.</li> </ol> <p>The Project fulfills all these issues by:</p> <ol> <li>Creating a User Profile system type forum.</li> <li>Allow users to register, upload and download domain-peptide PPI data in the specified format.</li> <li>Modify the DV-IMPACT database present in the server to handle the upload to the admin tools in PSIMI-TAB format.</li> </ol> <p>Link to the evaluation task: <a href="http://dvimpact.herokuapp.com/" target="_blank">http://dvimpact.herokuapp.com/</a></p> <p>Github Repo: <a href="https://github.com/jajodiaraghav/DV-IMPACT" target="_blank">https://github.com/jajodiaraghav/DV-IMPACT</a></p>
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.