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.
This project aims to extend the existing cBioAbstractor prototype into a schema-driven formatting pipeline that assists curators in transforming heterogeneous supplemental datasets into cBioPortal-compatible formats. Currently, curation is a manual and time-consuming process due to inconsistent file structures, lack of automated schema mapping, and the need to interpret validation errors manually. This results in inefficiencies, variability, and high onboarding effort. My preliminary extension implementation suggests the feasibility of this approach by connecting existing components, introducing fuzzy column normalization, and providing a simple interface for file upload, transformation, and result inspection. Initial qualitative experiments show that the system can reconstruct correct cBioPortal formats from intentionally perturbed datasets, suggesting strong potential for reducing manual work and improving consistency.
Makerchip Flows aims at developing EDA flows for TL-Verilog leveraging Edalize backend, for open source tools/flows like yosys, Openlane, F4PGA, Silicon Compiler, and also commercial ASIC Synthesis and Simulation tools. The project involves developing Flows with TL-Verilog (Makerchip IDE or SandPiper-SaaS) and integrating them into the website or use as a standalone flow. This involves developing support for tools and creating flows in Edalize. This effort Makerchip Flows also extends to adding TL-Verilog frontend for Silicon Compiler. This wide range of support and ecosystem developments will make TL-Verilog and its ecosystem the go-to for Design, Simulations, FPGA visualizations, and other explorations just within the browser, creating a low cost and low barrier to entry for beginners and engineers.
This proposal aims to enhance the ScrapeConfig CRD to achieve stability and usability. Currently in alpha, the CRD lacks the originally intended 1:1 relationship with Prometheus configurations. The project outlines a roadmap to address these issues, focusing on adding necessary fields, extending support for service discoveries, and implementing thorough testing. The plan includes a strategy for graduating the CRD to beta and eventually stable versions, following Kubernetes API versioning guidelines. Deliverables: Updated ScrapeConfig CRD with added fields to support service discoveries and other configuration options. Thorough test coverage for the added fields and overall functionality. Graduation of the ScrapeConfig CRD to beta stage, with documentation outlining the upgrade process. Enhanced documentation providing up-to-date information on the CRD and migration guides for users upgrading if necessary.
This project will elevate Gemini API support across widely used open-source agent frameworks like LangChain, LlamaIndex, CrewAI, and Composio—bridging the gap between Gemini’s full capabilities and the tools developers use to build with it. By introducing support for advanced features such as multimodal inputs, structured function calling, and streaming outputs, I aim to empower developers to build highly interactive, context-aware agents with ease. The project will include contributions to core library integrations, detailed documentation improvements, and the development of end-to-end examples showcasing Gemini in action. The result will be a robust, user-friendly ecosystem for Gemini-based agent development—making it easier than ever for developers to harness its full potential within their own workflows, products, and research.
ROOT is CERN's data analysis framework, which is widely used for HEP applications. Currently, the UnROOT package supports reading the ROOT files in Julia. However, there is no support for writing into ROOT files, meaning users have to write to the ROOT files independently. This can be a pretty tedious task involving references and pointers, which is not user-friendly. The project aims to provide a write interface to the Julia community, allowing the ROOT users to experience the performance benefits of Julia and Julia users to use ROOT for HEP & data analysis without worrying about I/O. The project goal will be achieved by providing a baseline Julia package and four feature packages allowing users to write any data structure to the ROOT file. The interface will be safe, user-friendly and have a Julia-like interface.
This project aims to extend the ArduPilot Software-In-The-Loop (SITL) environment to support episodic reinforcement learning (RL). Rather than simply applying RL algorithms such as Q-learning, SARSA, or actor–critic, the primary goal is to develop and integrate an episodic framework that enables: • Monitoring and controlling simulation time; • Programmatically resetting the UAV state (position, velocity, attitude, etc.); • Capturing and replaying states for analysis. This framework, implemented primarily in Lua (with potential Python support for data processing and visualization), will establish a robust cycle where each episode is initiated, executed for a predetermined duration, and then restarted. By focusing on a reliable reset mechanism to return the UAV to a consistent starting state, the project creates a solid foundation for the eventual application of RL algorithms within the constraints of the SITL environment.
<p>KMyMoney is a cross-platform personal finance tracking app. It uses C++, Qt as its core and the UI is done using QtWidgets. KMyMoney 4.8 is equipped with debug functions and extended by an online update of the quote sources. This was added to Alkimia 8.0 The main goal of the project is to add that as a feature to KMyMoney version 5. I have planned to add this support to version 5 of KMyMoney, as a replacement for existing functionality in KMyMoney (as was done with version 4.8). After extending the support a user will be able to:</p> <ul> <li>Get a feature to debug the online quote.</li> <li>Check the source of the selected online quote.</li> <li>Open the source link in the browser.</li> <li>Online update of quote sources.</li> </ul>
DeepForest is a library for training and deploying deep learning models for forestry tasks. The library is built on top of the PyTorch deep learning framework and supports custom model architectures and loss functions, allowing users to create and train their models. It also supports multi-label classification, enabling the detection and classification of multiple tree species within the same image. The project I want to participate in is the Advancing Bird Detection and Classification in Hand-Held Airborne Imagery project and the goals are: 1 - A refined and optimized deepforest model for accurate bird detection and classification in hand-held plane imagery. 2 - An annotated dataset for training and testing, contributing to the improvement of the model's performance. 3 - Comparative analysis of bird count accuracy by species, providing valuable insights into the model's effectiveness.
<p>Surrogate modeling has become a staple in large-scale scientific computing applications like aerospace and chemical engineering where full evaluations of the model are too expensive to be directly utilized within analysis contexts. However, with the recent advent of pervasive deep learning through differentiable programming, the ability to mix surrogate techniques with neural network code has become a practical issue. Surrogates.jl is a new surrogate modeling library hosted under the DiffEq umbrella which supports differentiable programming to allow for accelerated deep learning. It is compatible with forward and reverse mode automatic differentiation.</p> <p>My plan is to develop more surrogates methods, such as but not limited to: Compactly supported surrogates, Polynomial expansions, Regularized minimal-energy tensor-product splines, Variable fidelity modeling, Mixture of experts and DENSE.</p>
<h3>EV3 as a storage device</h3> <h4>Introduction</h4> <p>OpenRoberta is a learning platform that uses a graphical programming language to program different robots. One of the robots supported by OpenRoberta is the Lego EV3, and it supports it in two main ways which both require a custom firmware. The problem with this approach is that the process of running a program include many steps and takes a lot of time. A simpler approach is needed, since a faster solution could increase the usage of OpenRoberta with EV3, especially in competitions.</p> <h4>Project goal</h4> <p>The goal of my project is to enable OpenRoberta to generate UF2 files, which will then be downloaded by the user and copied over the EV3 running the stock firmware. The user will then be able to start the program as if it were a program created with the official Lego Mindstorm IDE.</p>
<p>Path merging is a promising technique that speeds up dynamic symbolic execution by multiple factors. In Path merging expensive forking is minimized by statically analyzing and summarizing regions of code, which are then used during dynamic symbolic execution. This technique was first introduced by the name of Veritesting[1] for c programs and recently implemented for Java programs in Java Ranger [2]. Both works report substantial benefits from merging of paths, with the latter winning SVComp’2020, a competition among Java verification and analysis tools.</p> <p>In this proposal, I plan to: 1) support test case generation for Java Ranger that would support branch coverage criteria, and 2) experiment the feasibility of path merging of threads by implementing a simulated thread interpreter and using Java Ranger to path merge thread interleavings.</p>
We would like OpenCost to more effectively integrate with AI agents. To do this, we need to implement a Model Context Protocol (MCP) server to surface the information from the OpenCost API. This is a great opportunity to learn about MCP servers, and help us build an interface for AI agents to obtain reliable cost/usage information so that they can accomplish their business goals. Expected Outcome: We would like an MCP server integrated into OpenCost. This MCP server should support queries on allocations, assets, and cloud costs. The MCP server should support the full range of allocations, assets, and cloud cost query parameters. A demo video should be recorded showing an interaction with the MCP server, and used to obtain costing information in a conversational setting. In addition, integration tests must be created in the OpenCost Integration Tests repo that test all interactions with the MCP server.
This project develops a pip-installable Python library that bridges SymPy's symbolic mathematics capabilities with HPX's high-performance parallel computing framework. SymPy-HPX automatically generates optimized C++ code from symbolic mathematical expressions, compiles it with HPX integration, and provides a seamless Python interface. The library supports multi-dimensional arrays, stencil operations, and multiple equation systems, making it particularly powerful for scientific computing applications. Key features include automatic code generation with HPX parallelization, efficient runtime management, support for complex numerical operations, and a user-friendly Python API. The project progressed through four major versions, each adding significant capabilities: from basic expression handling to advanced features like multi-dimensional arrays and persistent runtime optimization.
PyDataStructs is a high-performance python package for data structures and algorithms providing C++ backend via Python C-API as well as a parallel computation that provides lightning performance. a) Single package for all data structures and algorithms. b) Consistent APIs and Clean Interface. c) Supported on all three platforms - Windows, macOS, and Linux. I aim to work on the following during the project duration - 1) Increase the scope of missing data structures and algorithms 2) Adding methods to current data structures to extend their support in other research and engineering backgrounds 3) Implementing the C++ backend to provide high performance 4) Enhancing the documentation for make it more user friendly and easy to follow 5) Aggressively test the newly added as well as the existing code to achieve 100% coverage which currently is at 99%.
Objectives: 1. Develop toolsets to help unify the development experience using dubbo's IDL mode and Non-IDL mode 2. Develop a set of translation tools to translate in-code interface definition to Protobuf IDL, so that the interface defined in-code can be easily migrated to other programming languages. Plan: 1. Community bonding 2. Basic and extended type mapping between portobuf and non-IDL protocol types 3. Add support to protocol specification in protobuf IDL 4. Add support to reverse translation from in-code interface definition to protobuf IDL 5. Wrap the toolsets into a easy-to-use CLI Deliveries: 1. A CLI that unifies the development using dubbo's IDL and Non-IDL mode 2. Protobuf extensions to help acturalize the features mentioned above
Automated software engineering helps developers of control software to manage complex industrial applications. Eclipse 4diac has, in recent years, advanced in terms of providing tool support for domain experts. The control software is typically executed in real-time and distributed across devices. Designing such systems is complex due to the need for communication between devices. To detect faults early, modeling implicit assumptions within IEC 61499 software can provide the basis for automated checks. Such assumptions are typically described in constraint languages, which are difficult to use by automation experts. Therefore, this project provides the infrastructure for tool-assisted communication engineering. Where user interactions are required, graphical visualizations are provided. Current infrastructure for generating automated communication does not support the variety of communication protocols that is observed in modern automation systems.
Cluster API Provider AWS (CAPA) enables the creation of Kubernetes clusters in AWS with Cluster API. CAPA allows you create EKS and non-EKS based Kubernetes clusters. When creating a non-EKS cluster we must use AMIs for the nodes in the cluster. The project publishes some AMIs for non-production use. However, the process for publishing the AMIs needs improvment. Firstly we want to fully automate the publication of new AMIs when there is a new Kubernetes version available. Secondly, we need to implement the "AMI Publication Policy" for the project which will involve automated house keeping of AMIs. And thirdly we want to add back support for base operating systems that where temporarily dropped. - Expected Outcome: Automated AMI publication and deletion inline with the projects policy. Support for additional operating systems.
The way humans interact with each other occurs in multimodality. We not only articulate words, but also we show them. Expressing different concepts such as time, place, and emotion comes with speech and some movements called body gestures. In this study, we propose a multi-modal method that captures different patterns of body gestures aligned with an articulated time expression such as "from beginning to end". Our proposed architecture lies on two neural networks, the Compact Transformer and the Long-Short Term Memory (LSTM). Compact Transformer which is the current State-of-the-art structure for temporally distributed images also performs well over low-resourced data. LSTM performs well over temporal data with long-term dependencies. The hypothesis of this project is the existence of a relation between the body gestures and the time expressions we speak and using neural networks we try to accept or reject this hypothesis.
<p>CppSharp is a tool and set of libraries which allows programmers to use C/C++ libraries with high-level programming languages (such as C#). It is a tool that takes C/C++ header and library files and generates the necessary glue to surface the native API as a managed API. Such an API can be used to consume an existing native library in your high-level code or add scripting support to a native codebase. The supported target languages at present are C# and C++/CLI. It can also be used as a library to parse native code into a syntax tree with a rich declaration and type information model. This, thus, demands a lot of improvements and maintenance tasks as per the feedback from the users over the course of time. So, I'll try to fix as many bugs as I can and add as many new useful features that I can.</p>
<p>ChainerX is a versatile <code>ndarray</code> implementation with special support of deep learning-specific operations. Therefore, it is important to support many fundamental operators usually available for <code>ndarray</code> libraries (e.g. those provided by NumPy and SciPy) as well as special operators focusing deep learning applications (e.g. convolution, pooling, activation functions, etc.). While Chainer implements many of these operators, ChainerX still has low coverage. Full coverage of Chainer’s operators (<code>chainer.functions</code>) and more coverage of NumPy APIs is needed. Linear algebra operations form the backbone for most of the computation components for many machine learning methods and simulations of physical systems. This project aims at extending ChainerX capability for common numerical linear algebra routines.</p>
This feature request aims to automate the building and publishing of OS images that are used in Kubespray CI testing. Currently, these images (defined in `test-infra/image-builder/roles/kubevirt-images/defaults/main.yml`) must be manually created and pushed by maintainers. Automating this process would reduce manual work, eliminate bottlenecks when maintainers are unavailable, and could include automatic cleanup of outdated or unused images, while still retaining images needed for older supported release branches. - Expected Outcome: A CI job (likely post-merge and possibly periodic) that automatically: 1. Builds the required Kubespray OS images used in CI for tested distributions. 2. Pushes these built images to the appropriate registry. 3. Cleans up old or no longer needed images but retains those required for supported release branches.
There is a RISC-V Vector backend in OpenCV universal intrinsic, but the performance is very poor and only supported fixed vector size with 128 bit. The reason for the performance issue is speculated to be redundant instructions introduced by the wrapper class. And the fundamental problem is that the current design of Universal Intrinsic may not suitable for variable-size(size-less) architecture. So it would be nice to modify the API and implementation of universal intrinsics forvariable-size architectures. And the goal of this project is to optimize the current Universal Intrinsic for RVV, mainly including the following two points. 1. Reduce the overhead of using wrapper class and 2. Support for multiple VLENs The expected outcomes of this project is mainly including 1. a new Universal Intrinsic backend for RVV to opencv_core module 2. a new test cases (modify or add) and make it pass on QEMU
<p>FFmpeg DNN (deep neural network) module supports the dnn-based filters, it has two backends, one backend is TensorFlow which invokes TensorFlow C library for model loading and inference, the other backend is native. The native backend is a CPU fallback option when the system does not support TensorFlow, and so we can’t introduce 3rd party library for native mode. The native mode is still in early development stage and the performance has not been tuned yet.</p> <p>This project focuses on the native conv2d layer optimization with c/asm on Intel CPUs. Firstly, we will do some research on how to implement conv2d layer in a way which is convenient to operate parallelly. Secondly, write the corresponding C code for preliminary optimization. Thirdly, add some x86 SIMD optimization for conv2d layer to get better performance.</p>
The MBDyn Python Preprocessor aims to streamline the creation of input files for MBDyn simulations by bridging Python scripting with MBDyn's input format. Currently lacking support for all MBDyn entities, the preprocessor needs extension to cover all available entities. Additionally, integrating the preprocessor with Blendyn, a Blender add-on for post-processing MBDyn output, will provide a GUI based preprocessor for generating MBDyn input files. The project entails incremental development, starting with familiarization and planning, extending the entity library, managing model behavior, creating a model container, integrating with Blendyn, and finally, incorporating methods for aeroelastic models. These milestones culminate in deliverables that enable users to build entire MBDyn models using Python, including support for rotary-wing aircraft models, while ensuring completeness through thorough review and documentation.