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>The primary aim of this project is to make enhancements to Zulip’s REST API Documentation framework, which allows writing API Documentation based on the OpenAPI standard with built-in automated tests.<br> Major tasks include modifying the framework and testing to allow generating API pages directly from OpenAPI data and removing the redundant templates, and adding support for auto-generated API bindings by integrating different tools into the framework.<br> The docs will also be visually enhanced by improving the organisation and UI of /register and /events endpoints, and /api pages in general. This would include major design changes to the documentation pages to improve the overall user experience. Further, the OpenAPI data for currently undocumented /api endpoints will be added to improve the endpoint coverage by the docs.<br> This project would also involve fixing the currently open issues related to API Docs area, majority of which improve the testing of OpenAPI data, as well as making various API migrations with appropriate updates in OpenAPI data. Also, improvements would be made to the organisation of OpenAPI data and its testing/error messages to make it easier to maintain and work with.</p>
<p>CircuitVerse is an online circuit simulator that can be used as an online classroom companion for circuit simulation related needs of teachers and students.</p> <p>The aim of the project is to integrate CircuitVerse with as many Learning Management Systems such that teachers and students of different educational institutions can use CircuitVerse without leaving their favourite Learning Management Systems (Like Moodle, Canvas, Sakai etc.)</p> <p>A novel method has been developed to integrate <a href="https://www.imsglobal.org/activity/learning-tools-interoperability" target="_blank">Learning tools Interoperability</a> specifications with the existing Ruby on Rails codebase of CircuitVerse such that the platform can be used seamlessly with LTI supported Learning Management Systems (Like Moodle, Canvas, Sakai etc.)</p> <h4>Read More</h4> <p><a href="https://github.com/CircuitVerse/CircuitVerse/pull/2382" target="_blank">Final Pull Request</a> | <a href="https://blog.circuitverse.org/posts/ayan_phase_1_report/" target="_blank">First phase report</a> | <a href="https://www.ayanbiswas.in/tag/gsoc21/" target="_blank">See all blogs</a></p>
<p>AFL++’s mutation engine is optimized for compact data formats, such as images, multimedia, compressed data. However, the current AFL++ does not support grammar and therefore struggles with highly-structured inputs like PHP, JavaScript, or HTML . Although AFL++ allows users to define a dictionary, including language keywords, to help generate inputs, it still lacks more structured descriptions of the underlying syntax.</p> <p>To tackle the existing limitations of AFL++, the main goal of this project is to develop a pluggable grammar mutator that is integrated with AFL++’s mutation engine and can efficiently generate grammar-aware inputs. On one hand, like Nautilus, we want to combine grammar mutators with AFL++’s mutation engine. Also, we want to avoid the potential limitation of Nautilus: “over time Nautilus de-generates to structure-unaware greybox fuzzing”, as indicated by AFLSmart paper. On the other hand, we want to generate test cases efficiently as F1 fuzzer. Furthermore, to improve usability, we will develop a program generator that takes the grammar model as input and generates a mutator library, which is based on AFL++’s custom mutator APIs.</p>
The Volcano project currently uses Hugo for building its official website. However, current Hugo version of the website is pretty old and lacks modern features and flexibility, especially it is difficult to extend styles such as secondary menus, and there are problems such as invalid rendering of new markdown syntax. Docusaurus is a modern documentation framework that provides better support for versioning, localization, and theming. This mentorship focuses on modernizing the Volcano website by migrating it to Docusaurus, improving documentation structure, maintainability, and overall user experience. The project will involve replicating and enhancing the existing theme, restructuring documentation, improving navigation, and aligning the site with CNCF documentation best practices. The mentorship will also explore long-term maintainability and contributor-friendliness of the documentation workflow, especially to ensure that the documentation in the Volcano website is automatically synchronized with the documentation in Volcano's other code repos, using some automated tools like agents to keep the Volcano website up-to-date. - Expected Outcome: - Successful migration of the Volcano website from Hugo to Docusaurus - Improved documentation structure, navigation, and UX - A maintainable and contributor-friendly documentation setup - Clear contribution guidelines for future documentation updates
This project aims to create a ROS2 package that automatically converts C/C++ structs into ROS2 messages and generates the corresponding TypeAdapters. This removes the need for developers to manually define message files or boilerplate conversion logic, making it easier to use C/C++ structures directly in ROS2. The package uses castxml to generate an abstract syntax tree, parse it with pygccxml, and extract c/c++ structs definations. Then, Jinja templates are used to generate ROS2 msg files and the corresponding Type Adapter from the parsed data. For opaque or external library types (e.g., Eigen), the system will support a mechanism to register custom TypeAdapters, allowing users to define conversion logic manually that can be included by other ROS2 packages. Deliverables: - Parser using castxml + pygccxml to extract struct definitions and a Jinja-based generator to produce ROS2 Message files and Type Adapters. - CMake macros/functions that can be used in ROS2 packages to register generated msg files to rosidl and install the type adapters. - Examples demonstrating usage of CMake functions/macros, auto-generated messages and type adapters in other packages.
<p>The Systems Biology Markup Language (SBML) is the main language for representation and exchange of computational models in biology. JSON is the main data format of the web. Currently, many issues exist with the JSON representation of SBML used by tools like cobrapy, escher, ModelPolisher or the BiGG database.</p> <p>The idea of this project is to update the JSON scheme to have a full coverage of features important for constraint-based methods, i.e. SBML core and the additional SBML packages fbc and groups. In addition, existing issues related to SBML-JSON will be solved. The project will be implemented as part of cobrapy with main focus on the following:</p> <ol> <li>Annotation and meta-data support will be implemented</li> <li>Validation of JSON-SBML files will be performed</li> <li>Roundtripping SBML-JSON-SBML without information loss will be implemented</li> <li>JSON (SBML) scheme and scheme validation will be implemented</li> </ol> <p>Hence, a full-featured JSON exchange format for SBML will improve the web-integration and exchange of SBML models on web.</p>
This project tackles the challenge of learning hidden symmetries in complex, high-dimensional physics data using modern machine learning techniques. In particular, we aim to discover symmetries directly from raw CMS calorimeter data using a semi-supervised learning pipeline—without relying on pre-defined augmentation strategies or prior knowledge of symmetry transformations. We will build on recent advances in symmetry discovery such as adversarial learning, Lie algebra-based models, and general equivariant MLP construction. The proposed approach begins with a supervised baseline using known augmentations to validate the pipeline, followed by implementing a GAN-based or contrastive method to infer latent group actions and conserved quantities. Discovered symmetries will then be used to construct equivariant neural networks that are robust, interpretable, and data-efficient. By the end of the project, we aim to deliver a fully working, open-source pipeline for symmetry discovery and equivariant modeling on CMS data—benchmarking its performance and generalization against traditional models. This work will contribute to the broader mission of physics-aware machine learning and enable more principled modeling of detector data in high-energy physics.
Migrating content between different CMSs like Joomla, WordPress, and Drupal is challenging due to their distinct data structures. Traditional migration methods require custom tools for each CMS pair, leading to an O(n²) scalability problem. This project introduces a Common Content Model (CCM) as an intermediate format to simplify migrations to O(n) complexity. Using Model-Driven Engineering (MDE), we will dynamically adapt to various CMS schemas and automate migration script generation. The solution will be a Joomla component acting as a universal mediator to extract and transform content between CMSs. It can be installed on any Joomla instance, either directly or as a temporary migration app to handle API-based content migration between any CMSs. This project reduces development overhead, enables reusable migration structure, and positions Joomla as a central hub for content exchange across platforms. Deliverables: * CCM Joomla Component: A standalone migration component built for Joomla. * WordPress-to-Joomla Migration: Real implementation example using the CCM. * Testing Suite: Unit, integration, and E2E tests to ensure migration reliability. * Documentation: Clear guides for extending to other CMSs.
This project introduces an AI-powered agent that automates the transformation of API responses into structured UI schemas and functional UI components across various frontend frameworks. Using Multiple LLM-Based Agents, the system eliminates the need for manual UI creation by intelligently analysing API responses and generating corresponding UI structures. Additionally, it enables dynamic modification of UI components based on user prompts, allowing for customisation in design, layout, and behavior. By seamlessly integrating these capabilities into a unified workflow, the project streamlines frontend development, reducing manual effort and accelerating the UI generation process with a single-click solution. The project also aims to create a simple one-click API Request to Tool Generation pipeline that can enable external AI agents to interact with APIs without any manual coding Deliverables: • A Modular AI Agent Creation & calling mechanism for apidash's future AI-based tasks • One-Click solution to generate UI components from an API Response • One-Click solution to automatically generate API Tools to be used in various Agentic Frameworks like Langchain, Autogen and so on.
<p>The increasing number of sensors orbiting the earth is systematically producing larger volumes of data, with better spatiotemporal resolutions. To deal with that, better accurate machine learning approaches, such as Deep Learning (DL), are needed to transform raw data into applicable Information. Several DL architectures (e.g. CNN, semantic segmentation) rely only at spatial dimension to perform, for example, land-cover/land-use (LCLU) maps, disregarding the temporal dependencies between pixels observations over the time. Also, high-res remote sensing data (e.g. Planet, Sentinel) may provide more consistent time-series, that can be use in the identification of important LCLU classes, like crop, pastureland and grasslands.</p> <p>This potential can be explored using Recurrent Neural Networks (RNN), a specific family of DL approaches which can take into account time dimension. A promising project idea would be implement a RNN approach (e.g. LSTM) to classify a Sentinel time-series that is able to produce a map for one or more LCLU classes and ship the final version of the model into the Pycoal library as part of the COAL project.</p>
The DU Event Board currently uses manual inputs and basic validation to manage event data. As the number of events grows, this can make it harder to maintain consistency, avoid duplicate entries, and optimize API usage. Event discovery is also primarily based on simple filters and does not yet include offline access. This project improves how event data is processed and maintained. On the backend, it extends the existing GitHub Actions workflow to automatically fetch event metadata (image and description), detect duplicates using title and date similarity, and perform geocoding only once per event by writing coordinates back to the source file. These changes prevent duplicate entries, reduce repeated API calls, and remove the need for manual data fixes. On the frontend, the project adds full-text search, map-based filtering with a time slider, relative date display, and offline support. It also introduces a guided event submission flow that creates structured GitHub Issues, making it easier for contributors to add events. Together, these changes reduce manual review work and make it easier for users to search, filter, and access events.
As industrial manufacturing accelerates its digital transformation through advancements in robotics, adaptive production lines, and smart testing systems, cloud-edge collaboration has emerged as a critical enabler for deploying embodied intelligence in complex operational environments. Contemporary industry requirements for embodied intelligence now extend beyond basic task execution to encompass multimodal perception-decision integration, dynamic environment adaptation, and distributed device orchestration. Existing benchmarking frameworks exhibit limitations in evaluating scenario-specific embodied attributes inherent to industrial settings. This initiative leverages the KubeEdge-Ianvs collaborative AI framework, integrating domain-specific test datasets, simulation environments, and quantitative metrics to establish a certified industrial-grade evaluation infrastructure for embodied intelligence systems. Expected Outcome: 1. Develop an industrial-grade embodied intelligence dataset through systematic classification and reorganization of existing resources across four standardized task categories 2. Design standardized validation suites within KubeEdge-Ianvs 3. Deploy reference baseline algorithms using the developed validation suites to establish performance benchmarks within KubeEdge-Ianvs
Learning Tokens register the process of transfer and acquisition of knowledge. They track what we know and how we learned it in individual profiles that help personalize education. They measure engagement in the transfer of knowledge, support educational management, and foster Anatole France's words, nine-tenths of education is encouragement. Learning Tokens recognize, register, and reward community engagement in collective learning while certifying skills acquisition and individual competencies. In 2021, we did a global directory of DLT/Blockchain learning places. Last year, we defined artifacts for learning tokens, and now we shall code their Smart Contracts for MOOCs. Learning Objectives - Understand the tokenization of learning experiences. - Use the Inter Work Alliance Token Taxonomy Framework, IWA-TTF. - Apply IWA Token Designer to create Learning Tokens Templates. - Deploy them in Hyperledger Besu. - Understand granular learning interactions in MOOCs. - Explore simple ways to integrate Learning Tokens and MOOCs. Expected Outcome - Deploy Learning Tokens in Hyperledger Besu. - Report about connecting IWA-TTF to Hyperledger Beso - Explore alternatives to integrate Learning Tokens into MOOCs. - Report about possible alternatives to integrate Learning Tokens into MOOCs
<p>Fuzzing is a recent trend for systematic testing of interfaces by trying more or less random inputs and iterating over them. A subset of fuzzers uses code-coverage as feedback when permuting and choosing inputs, among them the popular user-space fuzzer American Fuzzy Lop. Recently there have been attempts to port fuzzers to the kernel and in a similar manner should now the hypercall interface of Xen be tested.</p> <p>While this is overall a very comprehensive problem this project will help to develop a better understanding of the problem space and make at least first advances of the source tree into the necessary direction. A generic mechanism will be implemented allowing fuzzers to obtain feedback on code-coverage. In the next step this output will be further processed in order to actually run a particular fuzzer (such as AFL), although there might not be sufficient time to commit this to the source tree.</p> <p>To sum up, the overall steps to getting a fuzzer running are the following:</p> <ol> <li>Extracting the execution path from the hypervisor via a hypercall</li> <li>Parse the execution path into a format consumable by a user-space fuzzer</li> <li>Drive a domU to execute the test cases of the fuzzer</li> </ol>
OpenMRS lacks a printable visit summary, forcing patients to verbally relay medical history during referrals and care transitions. This project adds a Visit Summary PDF generator to the existing openmrs-module-patientdocuments module, reusing the proven Patient ID Sticker pipeline (DataSetEvaluator, XML Renderer, Apache FOP). The backend gathers visit-scoped clinical data (vitals, diagnoses, lab results with reference ranges, allergies, medications, visit notes) via batch queries, renders it as XML, and transforms it to PDF through XSLT. An extensible VisitSummarySectionProvider SPI allows any module (billing, appointments, pharmacy) to contribute sections without modifying the core module. Configuration uses deploy-time Initializer keys for section toggles, concept UUIDs, and page sizes (A4/A5/A6). The frontend adds a print button in the O3 visit-detail-overview-actions slot with iframe-based PDF preview and download fallback. Deliverables include the complete backend pipeline with all clinical sections, extensible SPI architecture, configurable XSLT stylesheet, REST endpoint with privilege enforcement, frontend print extension, comprehensive tests, and documentation.
<p>Krita digital painting app relies on quick painting response to give a natural experience. A painted line is composed of thousands of images placed one after the other. This image mask creation hast to be performed super fast as it is done thousands of times each second. If the process of applying the images on canvas is not fast enough the painting process gets compromised and the enjoyment of painting is reduced.</p> <p>Optimizing the mask creation can be done using the AVX instructions sets to apply transformation in vectors of data in one step. In this case the data is the image component coordinates composing the mask. Programming AVX can be done using Vc optimization library, which manages low level optimization adaptable to the user processor features. However the data must be prepared so it optimizes effectively. Optimization has already been done on the Default brush mask engine allowing it to be as much as 5 times faster than the current Gaussian mask engine.</p> <p>The project aims to improve painting performance by implementing AVX optimization code for Circular Gauss, Circular Soft, Rectangular Gaussian, Rectangular Soft Rectangular and Stamp mask.</p>
CircuitVerse currently handles every user and classroom in isolation with no concept of institutional ownership. This makes it impossible for universities to manage hundreds of classrooms, instructors, and students under one umbrella. This project introduces an Organisation layer to CircuitVerse. It adds a hierarchical structure where an Organisation contains Department Groups, which contain existing CircuitVerse classrooms. Role-Based Access Control enforced via Pundit gives each role: Org Admin, Group Lead, Instructor, and Student, exactly the permissions they need and nothing more. Single Sign-On via OpenID Connect lets students log in using their existing institutional email through Google Workspace or Microsoft Azure AD, with automatic org assignment based on email domain. Optional custom branding adds subdomain support and logo placement for institutional identity. Deliverables: 1. Hierarchical org structure: organisations, org_groups, memberships tables with full admin dashboard 2. RBAC via Pundit: four roles enforced at the server level 3. SSO via OIDC: omniauth-openid-connect with domain-to-org auto-assignment 4. Custom branding: subdomain routing and logo rendering (optional)
<p>Deformation is one of the most ubiquitous and recognizable physical phenomena: trees swaying in the breeze, a bouncing ball, someone poking the Pillsbury doughboy. This familiar behavior can make all the difference to an immersive gaming experience. Simulating this behavior in real-time often falls within the domain of soft-body dynamics, for which Godot provides support in 3D.</p> <p>After discussion with developers in the Godot community, I have decided to focus my attention on two specific, feasible tasks that would improve soft-body dynamics in Godot:</p> <ol> <li><a href="https://github.com/godotengine/godot/issues/36693" target="_blank">[Issue #36693]</a> Enable area detection and the application of custom gravity for soft bodies</li> <li><a href="https://github.com/godotengine/godot-proposals/issues/2591" target="_blank">[Proposal #2591]</a> Enable the application of wind-like forces to soft bodies</li> </ol> <p>These two tasks are interrelated in that they both focus on the application of forces (body and external) to soft bodies, and I hope that their completion will illuminate a more general pattern by which this is best accomplished for future soft body improvements.</p>
This project introduces WHOIS details lookup and fuzzy location estimation to improve OpenWISP’s device management capabilities. When a device’s reports a public IP, WHOIS information will be retrieved asynchronously using Celery and the geoip2 library, ensuring non-blocking performance. Estimated locations will be marked with an is_estimated flag. Administrators will be able to filter such entries in the admin interface using custom filters, while APIs will provide equivalent filtering through django-filters. Serializers will expose both summary and detailed WHOIS records via the API. Configuration of these features will be available at both global and organizational levels using FallbackBooleanChoiceField, maintaining consistency with existing configuration practices. With this implementation, users will be able to view WHOIS data and approximate device locations when IP changes occur, refine locations manually, and receive notifications upon location updates. The Device admin UI will display WHOIS details and support filtering by estimated locations, while the Location admin will include clear indicators and filters for estimated entries. APIs will deliver the same functionality, ensuring consistent behavior across interfaces.
Microcks (https://microcks.io/) is a cloud native, open source tool under CNCF for API and microservices mocking and testing. This project aims to support the growing Microcks adopter community by fostering a collaborative effort to document production-grade deployment strategies for cloud environments. While the core Microcks maintainers focus on features, security, and enhancements, the adopters are responsible for production setups. However, a shared repository of best practices can help users learn from one another in a true open-source spirit. This project will empower the community to deploy Microcks confidently in diverse cloud environments, fostering collaboration and sharing of expertise among adopters. Expected Outcome: Participants will contribute to the Microcks community repository (https://github.com/microcks/community/tree/main/install) by documenting deployment workflows for popular cloud providers, such as AWS, GCP, and Azure, as well as other providers like OVH, Oracle, Scaleway, or Koyeb. Deliverables will include guides on utilizing cloud-native services (e.g., PostgreSQL, MongoDB, IDP) to create robust and scalable Microcks installations ideally on managed Kubernetes services from the provider.
<p>We will combine the JuliaDB.jl package, for tabular data manipulations in Julia, with WebIO.jl and InteractNext.jl to build a user-friendly web-based app for data analysis and visualizations.</p> <p>We will draw from PlugAndPlot.jl, a previous attempt based on QML and focused on the analysis of population data. The advantages of the new JuliaDB/WebIO based approach are:</p> <ul> <li>we can exploit JuliaDB's unique features, such as parallel storage and computing, support for online statistical techniques and machine learning techniques</li> <li>WebIO allows deploying in a wide variety of frameworks: the Julia IDE Juno's plot pane, Jupyter notebook, an Electron window or a web page via Mux.jl</li> </ul> <p>The web page deployment is particularly relevant in our view as it allows to make interactive data visualizations easily accessible online.</p> <p>Finally, rather than building a monolithic app, we will modularize our design to the extent possible, thus allowing different projects to reuse parts of it to create GUIs with different designs or based on different algorithms and visualization packages.</p>
Cluster API (CAPI) provides declarative APIs and tooling to provision, upgrade, and operate Kubernetes clusters. This project continues an existing Headlamp plugin to deliver first-class UI support for CAPI resources (Clusters, Machines, MachineDeployments, KubeadmControlPlanes). The plugin will let operators discover, inspect, and manage cluster lifecycle objects in Headlamp, visualizing hierarchical relationships and closing gaps in the plugin. Expected Outcome: - Sidebar and Map: List key CAPI CRs in the sidebar and Map view; show Clusters with Machines, MachineSets/Deployments, and control planes. - Resource details: Dedicated pages with CAPI-specific fields (conditions, infra refs, provider info, control plane refs, node pools, cluster membership, provider status). - UI integration: Map visualization, sidebar icons, on-hover "Glance" tooltips. - Robustness and tests: Fix runtime errors, human-friendly fields (e.g., "2d5h"), add automated tests. - Polish and delivery: Refined tables, icons, clickable "Controlled by" links; packaged in Headlamp’s plugin repo with install and developer docs; Kubernetes Blog post showcasing benefits.
Toolkit for Multivariate Analysis (TMVA) is a multi-purpose machine learning toolkit integrated into the ROOT scientific software framework, used in many particle physics data analysis and applications. Currently, we are developing a fast inference system in TMVA, called SOFIE, that takes takes ONNX model as input and produces compilation-ready standalone C++ scripts as output. These scripts will then provide users an easy way to deploy their deep learning models in their physics software and analysis frameworks. This project will focus on development of some missing deep learning operations which will allow to build more complex networks within TMVA for parsing the Transformer based models and Graph Net Models in SOFIE. Specifically, we propose to implement the inference functionality of some ONNX operators in the code generation format. The student can choose to build this based on existing implementations in TMVA or other existing machine learning software tools or build their own from scratch. The expected result is a working implementation of modular operators classes that implement the operators as defined by the ONNX standards in the code generation format. The project requires also to write the corresponding unit tests need to validate the written code.
The award-winning SERV (https://github.com/olofk/serv) is the world's smallest RISC-V CPU and is suitable for deeply embedded applications where chip area is at a premium. In a real system however, not only the CPU sets the system size and the smaller the CPU, the more important to also minimize the memory size. Adding support for the C ISA extension (compressed instructions) to SERV would enable RISC-V to reach even more use-cases on the deeply embedded side. SERV is an open source bit-serial RISC-V implementation written in Verilog with an emphasis on resource efficiency. The addition of the C ISA extension is expected to consist of changes to the instructions fetcher, an extra optional decoder stage for converting the compressed instructions into their non-compressed equivalents as well as other changes related to the PC not necessarily being word-aligned. On the infrastructure side, the relevant test suites (riscv-formal and riscv-compliance) are expected to pass and it should run the Zephyr operation OS with compressed instructions enabled. The SERV FuseSoC core description file should also be updated to allow users to conditionally select the C ISA extension at compile-time for simulation and FPGA/ASIC targets.