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>In GSoC 2020, The TFLite team and I released the <a href="https://docs.google.com/document/d/1zm9Ifiql4aFKTXMdEe0FXlEU83g6l5jWCO8a3BtHeI0/edit?usp=sharing" target="_blank">TensorFlow Lite Support Suite</a> consisting of TFLite Flutter Plugin, TFLite Flutter Helper Library, and a couple of example apps with tutorials. The project is receiving excellent comments from the community, as they are finally able to build performant Flutter ML apps with models and TF versions of their choice. The recent release of Flutter 2.0 should attract even more users. This year, we plan to extend the TFLite Flutter Support Suite based on the users' feedback and latest developments in the TensorFlow Lite ecosystem.</p> <p><a href="https://github.com/am15h/tflite_flutter_plugin" target="_blank">TFLite Flutter Plugin</a> will be improved for better handling errors and supporting more platforms along with Android and iOS.</p> <p><a href="https://github.com/am15h/tflite_flutter_helper" target="_blank">TFLite Flutter Helper</a> will be updated to match developments in its Java counterpart.</p> <p><strong>Flutter Task Library</strong> based on the TFLite Android Task Library to provide out-of-box support for popular use cases like detection, question, and answer, etc. The Flutter Library will leverage the performance and capabilities of the C++ Task APIs through dart ffi bindings. Example apps to demonstrate the usage of Task Library.</p>
Scalable systems lay essential foundations of the modern information industry. HPC data centers tend to have hundreds to thousands of nodes in their clusters. The use of “extreme-scale” distributed systems has given birth to a new type of bug: scalability bugs. As its name suggests, scalability bugs may be presented depending on the scale of a run, and thus, symptoms may only be observable in large-scale deployments, but not in small or median deployments. For example, Cassandra-6127 is a scalability bug detected in the popular distributed database Cassandra. The scalability bug causes unnecessary CPU usage, however, the symptom is not observed unless ~1000 nodes are deployed. This demonstrates the main challenge of studying scalability bugs: it is extremely challenging to reproduce without deploying the system at a large scale. The project goal is to build a dataset of reproducible scalability bugs. Achieving this will involve analyzing bug reports from popular distributed systems like (e.g., Cassandra, HDFS, Ignite, Kafka) and determining if the reported bug depends on the scale of the run, such as the number of nodes utilized, the size of files, and the number of requests. Identified bugs will be used to build a dataset of bug artifacts that contain the buggy and fixed versions of the scalability system, a runtime environment that ensures reproducibility, and a workload shell script that would trigger some system functionalities and demonstrate the symptoms of the bug under different configurations. For example, a successful reproduction should be able to show the performance drop along with an increasing number of nodes.
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.
fts(3) is the file hierarchy traversal library used by nearly every recursive utility in FreeBSD like find, rm, ls, chflags, du, and others. It currently cannot operate inside Capsicum capability mode because it relies on path-based filesystem operations throughout traversal: opening the current directory by name, opening subdirectories by path, and resolving symlinks through constructed string paths. None of the utilities that depend on fts(3) can be Capsicumized until this is fixed. This project adds fts_openat(), a new entry point that accepts a pre-opened directory file descriptor as the traversal root, following the openat(2) convention. The existing fts_open() becomes a one-line wrapper over fts_openat(AT_FDCWD, ...), preserving full backward compatibility. The internal traversal engine is refactored to replace all path-based operations with fd-relative equivalents — openat() and fdopendir() for directory opens, dup() for CWD saves, and fstatfs() for filesystem type detection — while leaving the traversal state machine, path buffer, and cycle detection completely unchanged. The project is structured in two phases. The first and larger phase is a comprehensive ATF/Kyua regression test suite covering the complete documented behaviour of fts(3), built against the unmodified library as a safety baseline. The second phase is the internal refactoring, the new fts_openat() API, capability-mode tests using cap_enter() directly in ATF test cases, and a complete Capsicumization of chflags(1) as the end-to-end demonstration.
<p><a href="https://docs.opencv.org/3.4/df/d0a/tutorial_js_intro.html" target="_blank">OpenCV.js</a> is a JavaScript binding for selected subset of OpenCV functions for the web platform. It allows emerging web applications with multimedia processing to benefit from the wide variety of vision functions available in OpenCV. OpenCV.js leverages Emscripten to compile OpenCV functions into asm.js or WebAssembly targets, and provides a JavaScript APIs for web application to access them.</p> <p>However, now the performance of OpenCV.js still have a big gap with Native, and it can't support real-time tasks very well, such as <a href="https://docs.opencv.org/3.4/df/d6c/tutorial_js_face_detection_camera.html" target="_blank">face detection</a> and <a href="https://docs.opencv.org/4.0.0/d5/d86/tutorial_dnn_javascript.html" target="_blank">face recognition</a>. The biggest reason is that the current version of OpenCV.js runs with single thread and no SIMD, which greatly wastes the parallel computing power of the CPU.</p> <p>But at this time, WebAssembly can reduce the performance gap between Web and Native. WASM now support multi-threading with Web Worker and shareArrayBuffer, and is going on supporting new v128 value types used for SIMD, which can both improve the parallel computing capability on Web.</p> <p>Therefore, the main goal of this project is to speedup OpenCV.js by multi-threading and SIMD.</p>
<h3>Key mapping GUI</h3> <p>The goal of this project is to make it as easy as possible for the users of <em>Mixxx</em> to customize the keyboard mapping to their taste, without having to modify a <em>*.cfg</em> file and having to restart <em>Mixxx</em>. In order to achieve that, the idea is to make a GUI for the keyboard mapping. There are now two main controller types: <code>MIDI</code> and <code>HID</code>. This project is about developing the third one: <code>keyboard</code>.</p> <p>The <code>keyboard</code> controller will be always visible in preferences -> controllers. In contrast to the <code>HID</code>- and the <code>MIDI</code> controllers, which both have four tabs (Controller Setup, Input Mappings, Output Mappings and Scripts), the <code>keyboard</code> controller will just have two tabs: <em>Controller Setup</em> and <em>Key Mapping</em>. The <em>Controller Setup</em> will be the same as for the <code>HID</code> controllers, but the <em>Key mapping</em> tab will consist of a table with three columns:</p> <ul> <li>Action</li> <li>Key (Or 'Key Combination')</li> <li>Comment</li> </ul> <p>Assigning key combinations will be as easy as clicking the <em>key (combination)</em> cell and pressing the desired key (combination). If the given combination is already chosen for another action, both actions will be disabled and highlighted red, indicating an error.</p>
The application of Network Control Theory to medical neuroimaging consistently faces the approximation crisis. Current tools rely on infinite-horizon continuous models, binary structural masking and statistically inaccurate harmonization. They fail to capture the discrete, finite time and stochastic truth of brain dynamics grounded in biology. This limits their use in computational psychiatry and biomarker discovery. NeuroSim is intended as a Python model built from scratch to resolve these problems. It aims to simulate in-silico brain stimulation with rigorous physics-based constraints. Over the 350 hour period, the three prime modules will be made available to the community:- 1. Discrete Finite Horizon Physics: A transition from standard iterative summations to discrete time Van Loan Doubling algorithm, significantly reducing computational load for large scale neural networks. 2. GraphNet based Laplacian Regularization: Implementation of a proximal gradient descent module to generate soft-prior connectivity matrices. This resolves the problem of structural blindness in binary DTI-based masking. 3. Bias-less Harmonization and Ground-truthing: Deployment of a NeuroCombat protocol to ensure data security in multi-site studies. Validation to be done against non-linear Wilson-Cowan neural mass simulations. Using the above modules, NeuroSim positions itself as a highly scalable, diagnostic-adjacent toolset capable of modelling complex neural mass transitions. It establishes a standard for next generation non invasive neuromodulation and macro-scale brain stimulation.
This project aims at incorporating Physics informed neural network (PINN) based ODE solvers into the Diffusion probabilistic models(DPM) , to build a fast and efficient sampler for high dimensional complex probability distribution. Diffusion models are characterized by a probability flow ODE equation which needs to solved using numerical solvers to generate samples from the target probability distribution. In this project we replace the numerical ODE solvers with PINNs which are trained to represent the solution of the probability flow ODEs over a domain of values. This enables us to amortize the large upfront cost of training PINN to fast sampling speed once the model is trained. Different variants of PINN like models with hard constrains on initial/boundary conditions, augmented Lagrangian based models, can-PINN and neural operator based methods will be systematically tested on different non Gaussian 3D probability distribution like [ Mixture of Gaussian, 3D helical, Torodial distribution and Concentric spherical shells ]. I will be testing both single objective optimization and multi objective optimization techniques to handle the physical loss term and MSE loss term in PINN training. A systematic analysis of different variants of PINNs to solve the probability flow ODE will be presented with metrics to quantify the PINN representation error and comparison between the true probability distribution and samples from PINNDE. Depending on the viability of the results on the above mentioned tests, PINNDE method will be used on the fast colorimeter simulation challenge 2022 benchmark dataset 1.
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.
Stochastic dynamical systems play an important role in scientific and engineering domains, particularly in systems governed by Brownian motion or subject to random perturbations from the environment. Stochastic Differential Equations (SDEs) and Stochastic Partial Differential Equations (SPDEs) provide a mathematical framework to describe such complex stochastic behaviour. Understanding the hidden physics within these systems is pretty much essential for analyzing their stochastic and nonlinear dynamics. The NeuralPDE package in the SciML ecosystem currently lacks documentation for its existing SDE Physics-Informed Neural Network (PINN) solver and does not yet support multidimensional SDEs and SPDEs. This project aims to document the existing solver while also extending it to include PINN solvers for multidimensional SDEs based on the Wiener expansion, which expresses stochastic solutions as spectral expansions in terms of a set of random basis functions. The proposed SDE PINN solver uses the Kosambi-Karhunen-Loève (KKL) expansion for the Wiener process to obtain finite-dimensional approximations, effectively transforming SDEs into rough path ODEs. These ODEs can then be solved using the standard loss function formulation of PINNs for ODEs. As a natural extension, this approach can be generalized to SPDEs using the Polynomial Chaos Expansion (PCE), which extends the Wiener expansion to handle spatially distributed noise in stochastic systems. By developing and implementing these solvers, this project aims to enhance NeuralPDE's capabilities in solving high-dimensional stochastic systems, making it a more comprehensive tool for data-driven modelling and simulation of stochastic dynamical systems.
LLMs rely on floating-point arithmetic for inference, but the Logarithmic Number System (LNS) offers a compelling alternative: multiplication becomes integer addition in the log domain, and 16-bit LNS (xlns16) uses only 2 bytes per element, half the memory bandwidth of float32. This project integrates the open-source xlnscpp C++ LNS library into ggml (the compute backend of llama.cpp) as a proper ggml_backend, enabling LLM inference to run entirely in xlns16 arithmetic as a proof of concept. The implementation introduces GGML_TYPE_LNS16 as a native ggml datatype and implements the 13 operations required for a complete transformer inference pass (matrix multiply, softmax, RMS norm, RoPE, SiLU, residual add, along with some others), all using xlns16 kernels. Activations stay in xlns16 format throughout inference; weights are converted dynamically from their stored quantised formats (Q4_K_M, etc.) per kernel invocation using O(1) lookup tables. The backend is validated at two levels: a unit test confirms sub-0.6% relative error on matrix multiply, and an end-to-end run on SmolLM2-135M-Instruct confirms the full transformer executes without crashing. Deliverables: (1) GGML_TYPE_LNS16 datatype registered in ggml; (2) a complete ggml_backend for xlns16 arithmetic covering all ops needed for LLM inference; (3) integration with llama.cpp; (4) a validation test suite; (5) an accuracy analysis comparing LNS and FP output across model layers
<p>Data-Flow Integrity (DFI) offers robust protection against memory corruption by ensuring that runtime data flow matches a program's static data-flow graph. However, software DFI suffers from prohibitive overhead. Recent hardware solutions attempt to mitigate this by using decoupled coprocessors (e.g., RvDfi) or alternative architectures, but a tightly coupled approach that extends the ISA directly within the pipeline offers a compelling opportunity to optimize performance and area.</p><p><br></p><p>In a collaboration between the SUSHI research team (Inria Rennes) and the Barcelona Supercomputing Center (BSC), this mentorship implements tightly-coupled DFI in the open-source RISC-V Sargantana core. To ensure a realistic scope, the project is structured in two phases. Phase 1 focuses on hardware: the mentee will collaborate with a student at SUSHI who developed preliminary RTL modifications for the CVA-6 core. This accelerates porting and optimization of these ISA extensions for Sargantana.</p><p><br></p><p>Once the hardware is stable, Phase 2 explores the software stack. To keep the project tractable, the goal is an initial, proof-of-concept toolchain integration. The mentee will leverage adaptations started by SUSHI, using the RVDFI toolchain as a baseline. SUSHI's LLVM experts will provide guidance to help the mentee establish a foundational compiler backend. This phased approach guarantees a solid hardware deliverable while ensuring a full-stack proof-of-concept remains an achievable stretch goal.</p>
Machine learning algorithms are heavily relied on to understand the data generated at the European Council for Nuclear Research's (CERN) Large Hadron Collider (LHC) which produces immense amounts of data through the measurement of the products of particle collisions. Since data from these events can typically be formed into a graph structure, deep geometric methods, such as graph neural networks (GNNs), have been used as an approach to various HEP anlysis tasks. One such task is jet tagging, where jets are viewed as point clouds with distinct features and edge connections between their constituent particles. To enhance the validity and robustness of deep networks, embedded symmetries, which are present in many physically realizable datasets and fundamental physical theories, can also be discovered by the model through the use of invariant I(n) and equivariant networks E(n). However, due to the increasing size and complexity of these datasets, as well as the models which process them, an involved yet computationally inexpensive approach must be utilized. To handle an increase in the complexity of the data, I suggest the implementation of a classical attention (AT) transformer with the necessary modifications to incorporate, invariant or equivariant, and GNN layers. As the extension of classical algorithms via bit-wise processes to quantum algorithms via qubit-wise processes has been rapidly developing over the last few years, I propose the full development of general quantum invariant and equivariant graph attention transformer (QIGAT or Quantum Informer, QEGAT or Quantum Equiformer) architectures to meet the demands of requiring these machine learning algorithms to offer enhanced robustness through the adherence to fundamental physical principles while reducing their computational cost.
WasmEdge is a lightweight and cross-platform runtime for LLM applications. It allows developers to create LLM apps on a Mac or Windows dev machine, compile them to Wasm, and deploy them on Nvidia machines without any changes to the binary app. It achieves application portability across CPUs and GPUs by supporting a W3C standard API called WASI-NN (https://github.com/second-state/wasmedge-wasi-nn), which abstracts GPU-related AI functions as high-level APIs. At this stage, however, only inference functions are supported. In this project, we aim to support fine-tuning features in WasmEdge. It will improve the developer experience for WasmEdge-enabled LLM tools. To achieve this, we plan to extend the current WASI-NN spec by adding a set of extra APIs, and then implement them by delegating to corresponding functions in llama.cpp embedded in the WasmEdge GGML plugin. Expected Outcome: 1. Use llama2-7b as the base LLM for fine-tuning; the final implementation should handle it correctly. 2. Extend the WASI-NN (https://github.com/second-state/wasmedge-wasi-nn) spec if needed to support the fine-tuning feature. 3. Implement the fine-tuning functions inside WASI-NN ggml plugin. They will call the corresponding functions in llama.cpp, as the inference functions do. 4. Implement the LoRA-related functions inside the WASI-NN ggml plugin to load the pre-trained LoRA and verify the fine-tuned model. 5. Documentation, examples, tutorials, and demonstration are required.
Ultimate Alarm Clock III (UAC) aims to evolve into a production-ready, cross-platform mobile application that delivers intelligent, condition-based alarm functionality. The core problem addressed is the limitation of traditional alarms, which lack contextual awareness and flexibility in triggering based on real-world conditions such as location, calendar events, or user activity. To solve this, the project will enhance UAC with advanced conditional logic and deep integrations, including Google Calendar synchronization, Google Assistant voice controls, and customizable task lists linked to alarms. Additionally, the system will improve reliability through enhanced alarm history logging and debugging tools, while enabling seamless synchronization with a companion app. Infrastructure improvements such as CI/CD pipelines, automated testing, and Play Store deployment workflows will ensure scalability and maintainability. A stretch goal includes developing an iOS version with native background execution capabilities to ensure consistent alarm behavior across platforms. The key deliverables include: Implementation of core features such as calendar-based alarms, voice interaction, shared alarms, and task lists Advanced developer diagnostics via alarm history and logging systems Companion app synchronization with real-time data consistency A robust CI/CD pipeline for automated testing and deployment (Stretch) iOS support with native integrations for reliable background execution Together, these deliverables will transform UAC into a scalable, production-grade application with intelligent, context-aware alarm capabilities and a strong foundation for future development.
The existing Open Source Quartz Solar Forecast lacks live data integration from Enphase Inverters, hindering its accuracy and utility for Enphase users. Connecting these two systems would enhance forecast precision by 20% and enable users to compare forecasted data with real-time generation figures. The problem statement thus asks to seamlessly integrate live Enphase Inverter data into the Open Source Quartz Solar Forecast. I will use Python to develop a dedicated module and add it to the Open Source Quartz Solar Forecast library. This integration will involve retrieving live data from Enphase Inverters via the Enphase API and incorporating it into the forecasting algorithm. Upon completion, users will be able to leverage live data from Enphase Inverters within the Open Source Quartz Solar Forecast. I will thoroughly test this integration using authentic Enphase API credentials to ensure reliability. I will additionally deliver comprehensive example code and documentation, improving user experience and facilitating seamless execution of the forecast with genuine credentials. I will extend the project’s reach by compiling a curated list of analogous Solar Inverter companies to Enphase and write dedicated code to facilitate live data retrieval from these identified Solar Inverter systems, which will enable users to fetch live data from various solar inverter platforms and utilize it for forecasting purposes, similar to the capabilities provided for Enphase Inverters. This will empower users with diverse solar setups to benefit from accurate and insightful forecasting capabilities tailored to their specific systems.
Uyuni is a powerful systems management platform, but today it lacks a native way to automate actions based on events in real time. As a result, administrators often have to write custom scripts to react to things like patch updates or system changes, which adds unnecessary complexity and effort. This project aims to change that by introducing a simple, scalable event-driven architecture that turns Uyuni into an automation-friendly platform. The idea is to make it easy for administrators to connect Uyuni with other tools and build workflows without writing a lot of custom code. The solution has two main parts. First, an MQTT-based event publisher that hooks into Uyuni’s existing event pipeline and emits real-time events such as patch updates, system registrations, and Salt state results. Second, a custom Node-RED integration that allows administrators to visually design automation workflows using a drag-and-drop interface. The publisher is designed to be lightweight and non-intrusive, running as a passive listener so it does not interfere with Uyuni’s current behavior. It sends structured JSON messages, supports topic-based filtering, and includes reliability features like retries, batching, and rate limiting to handle larger deployments. On top of this, the Node-RED layer provides reusable nodes for consuming events, triggering actions, and interacting with Uyuni APIs. Overall, this project makes automation in Uyuni much more accessible, reduces the need for manual scripting, and enables easy integration with external tools like Slack or Jira. It also lays a solid foundation for building more advanced automation features in the future.
This project delivers an integrated framework to optimize cost, strengthen governance, and improve security operations for Apache Beam resources on Google Cloud Platform (GCP). Key deliverables include: GCP Cost Optimization for Taxi Pipelines: A targeted optimization effort for NYC taxi-related Beam tests and examples to reduce unnecessary Pub/Sub and Dataflow consumption. The work includes execution-bound controls, reusable datasets/snapshots, and safer cleanup practices to preserve reproducibility while lowering operational cost. GCP Resource Governance via IaC: A Terraform-based Infrastructure as Code baseline to define and enforce labels, TTL metadata, ownership fields, and lifecycle policies for high-cost services (BigQuery, Dataflow, Compute Engine, Artifact Registry, and Cloud Storage). This enables a version-controlled, auditable, and repeatable infrastructure governance model. Automated Inventory and Drift Detection: A continuous inventory and compliance pipeline integrated with GitHub Actions, BigQuery, and dashboards. The system will collect resource state, classify orphaned/non-compliant assets, run Terraform validation/plan checks, and detect drift between current infrastructure and declared baseline. Service Key Compliance Monitoring: An operational monitoring flow for service account keys that tracks rotation health, propagation status, TTL violations, and suspicious usage signals, with automated reporting and alerts. Safe Remediation Workflows: Disable-then-delete playbooks executed first in dry-run mode and later in controlled execution, providing secure and traceable cleanup of obsolete resources based on validated policy outcomes.
Currently InVesalius does not support simultaneous visualization of structural MRI and fMRI volumes. This is however of large interest to visualize both modalities for people involved in the clinical and analytical domain. Indeed a direct implication would be to have functional connectivity induced graphs visible along with structural connections (white matter). On top of which, after generating 3d maps, it may then be possible to visualize in space the functional connections versus structural connections. First of all, this project would be a useful feature to InVesalius, but secondly also to the neuroscience community. By having InVesalius open source and in a UI format it would enable clinical experts or neuroscientists without engineering background to have ready to go visualization of fMRI and structural MRI volumes. In general this could be extended to other modalities as well. Two possible ways to simultaneously visualize structural MRI and fMRI are: 1. Overlay different masks or contrasts (need to be carefully picked) for each of the two modality. There might be a need to apply some color distribution matching between structural and functional (e.g histogram equalization) since one would be T1 and the other T2 to have better visualization. Both slices would need to be co-registered prior to overlaying. The effect on the generation of 3D visualization would also be cared for. 2. Having two views or preview of fMRI in each orientation (sagittal, coronal, axial and 3d). Two views or one main view and a preview would require to have a tracker (dot) that points to the same voxels in the two views. This could be a way for the user to match regions for instance and essentially avoid crowding the visualization. The language I plan on using and believe fits the project would be python. The potential libraries used during the project would include already required ones for InVesalius (e.g scipy,opencv)
This proposal aims to address the challenge of robust and accurate GPS-denied navigation for UAVs equipped with lightweight 3D cameras. The core problem is that while camera-based visual odometry can struggle in certain environments and LiDAR systems are often too heavy and expensive for all UAVs, there is not a reliable way for lightweight UAVs to leverage the high-accuracy 3D maps generated by more capable mapping systems. The proposed solution is to develop a framework that allows UAVs with 3D cameras to utilize pre-generated, centimeter-level 3D maps for navigation. This will involve a C++ based ROS2 package designed to run on a companion computer. This package will: 1. Process the pre-generated maps. 2. Implement point‑cloud matching algorithms (such as ICP and NDT) to align live camera scans with the existing map and compute a 6‑DOF pose. 3. Fuse the estimated pose with IMU data using an Extended Kalman Filter (EKF) to provide smooth, high‑rate odometry and improve Z‑axis estimation. 4. Incorporate a state machine to manage odometry data, perform sanity checks (e.g. data‑rate drops, connection loss, time desync, corrupted messages), and transmit the validated pose to the UAV’s firmware via MAVLink over serial. The key deliverables of this project include: 1. A fully functional prototype in simulation capable of generating maps and producing 6‑DOF estimates with the 3D camera. 2. Algorithm design, implementation, and sensor fusion. 3. System integration, validation, and documentation. 4. A complete hardware setup.
<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>
This project addresses the issue of fragmented tools within the Kubeflow ecosystem, specifically Elyra, Kale, and Jupyter Scheduler, which complicates workflows for data scientists. The proposal aims to solve this by developing a unified JupyterLab plugin for Kubeflow. This plugin will consolidate and modernize the functionalities of the existing tools, providing a cohesive environment for developing, testing, and deploying machine learning workflows directly from JupyterLab. The plugin will achieve this by implementing seamless integration with Kubeflow Pipelines. Users will be able to convert notebook cells to pipeline steps, define and visualize pipeline workflows, submit pipeline runs, and monitor their execution status, all within JupyterLab. The plugin will be built with a modular architecture, including Python backend components for interacting with Kubeflow Pipelines and parsing notebooks, and TypeScript/React frontend components for the user interface. The key deliverables of this project are: • A unified JupyterLab plugin architecture consolidating Elyra, Kale, and Jupyter Scheduler functionalities. • Seamless integration with Kubeflow Pipelines, enabling notebook-to-pipeline conversion, workflow definition and visualization, pipeline submission, and monitoring within JupyterLab. • A user-friendly UI for pipeline development and management using modern React components. • Initial integration with Kubeflow Notebooks for easier notebook provisioning. • Comprehensive documentation and usage examples. • A robust testing framework to ensure plugin reliability, including unit tests, integration tests, user acceptance testing, continuous integration, and compatibility testing. This unified plugin is expected to significantly improve workflow efficiency for data scientists and ML engineers by bridging the gap between interactive development and production-grade ML infrastructure.
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.
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).