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>SegAnnDb (Segmentation Annotation Database) is a web app, which helps researchers analyze a chromosome profile for copy number alterations in genes. Many studies have found that copy number variations are linked to diseases like - cancer, tumors, Alzheimers etc. Study and analysis of CNVs is an active area of research in bioinformatics.</p> <p>SegAnnDB allows users to upload a profile and then annotate it on basis of <code>loss</code>, <code>gain</code>, <code>deletion</code>, and <code>amplification</code> Various profiles are stored in the webapp and researchers can work with them. SegAnnDB provides most accurate results when compared to other applications. It uses concepts of machine learning and data analysis to arrive at most accurate models.</p> <p>The aim of this project is to add various significant features into SegAnnDB , some of these will be -</p> <ul> <li>Test Suite</li> <li>Permissions System on profiles</li> <li>Replace large PNGs by sub regions of chromosome</li> <li>Faster Deletion of profiles</li> <li>Sharing of annotations </li> <li>Safe cleaning of generate log files</li> <li>Packaging it as docker container</li> </ul> <p>This project will greatly improve collaboration on SegAnnDB, it will also make its development easier and more people will start using it in their research and analysis.</p>
Currently, the StablePay ecosystem only processes payments for Djed Osiris. As the Djed protocol expands to include new variants like Djed Shu, Tefnut (ETH-backed), and Isis (ERC-20-backed), the payment infrastructure must evolve. The goal of this project is to refactor the StablePay widget, merchant dashboard, and demo sites to seamlessly support any Djed variant without hardcoded assumptions. Additionally, this project will introduce support for the Gluon protocol, which entails deriving the essential mathematical formulas required for pre-calculating neutrons and protons. To achieve this, I will develop protocol adapters that interact with abstracted Djed interfaces, allowing different stablecoins to be plugged in via configuration. I will upgrade the merchant dashboard to enable multi-stablecoin management, allowing merchants to set preferred price feeds and monitor per-stablecoin revenue. Additionally, I will build deployment tooling to auto-generate config bundles from on-chain metadata and improve the end-user UX to handle coin selection, oracle status, and fallback logic gracefully. Ultimately, this project will transform StablePay into a highly scalable, agnostic payment gateway. Deliverables will be secured with comprehensive integration testing (using Foundry/Hardhat) and frontend end-to-end testing, alongside detailed documentation for merchants to easily onboard new networks and protocol versions.
<p>PowerUp is an educational mobile for adolescent girls. The game is based on Social & Emotional Learning model to empower young girls to take charge of their reproductive health and self esteem.</p> <p>I will be working on PowerUp-iOS during GSoC 2017, and I plan to achieve the following tasks.</p> <h3>Code Refactoring</h3> <p>I will cut some redundant classes and view controllers as well as redesign the class structure and Storyboard segues. Future developers would benefit from the refactored code significantly due to the enhanced readability and flexibility.</p> <h3>Mini Games</h3> <p>Mini game is a nice way to make a choose-your-own adventure game more interactive. I will implement three mini games during GSoC 2017.</p> <ol> <li>Minesweeper Game: This is a game of pure chance, simulating the success rate of various contraceptive methods.</li> <li>Sink to Swim: This is a "myth buster" game to clear the myths and false information which public media and internet feed to young girls.</li> <li>Vocab Matching: This game is designed to teach players various terms related to contraceptives and body growth in puberty.</li> </ol> <h3>UI Update</h3> <p>I will be working along with a UI designer, so I will be applying the newly designed UI assets to the project.</p>
Kai is a tool designed to leverage AI for application modernization by analyzing code, identifying issues, and suggesting fixes. We aim to enhance Kai by developing a robust data querying mechanism to facilitate fine-tuning processes. This enhancement will lay the groundwork for potential future integration with InstructLab, an open-source AI project enabling community contributions to Large Language Models (LLMs) by adding new skills or knowledge. The primary focus will be on creating mechanisms to query and utilize data effectively, with a stretch goal of integrating static analysis tools and implementing an agent-based workflow. - This project will significantly enhance Kai’s backend, making it more scalable and capable of providing deeper code insights while also contributing to the enrichment of LLMs through InstructLab. It will offer a rich learning experience for participating students, covering backend development, workflow management, and contributing to open-source AI projects. - Expected Outcome: - Successfully develop and implement a data querying mechanism in Kai to facilitate fine-tuning processes. - Demonstrate the enhanced backend with improved data querying capabilities. - Participate actively in community meetings, presenting progress and insights. - Create a detailed blog post documenting the project, its outcomes, and potential future directions, including the possible integration with InstructLab. - (Stretch Goal) Develop a reusable module fo
Observable Public Cloud Infrastructure for IoT Developers is a project to enhance the Eclipse Thingweb ecosystem. The overarching goal is to create a comprehensive observability solution that empowers IoT developers with the tools they need to build, test, and debug Web of Things applications more effectively. By integrating OpenTelemetry into node-wot, enhancing the Test Things infrastructure, and providing intuitive monitoring dashboards, the project aims to solve a critical challenge in IoT development: the lack of visibility into distributed systems behavior. This project will transform the developer experience by providing real-time insights into application performance, protocol behavior, and system health, ultimately leading to more reliable and maintainable IoT solutions. I've structured my approach into three interconnected layers: the Core Layer integrates OpenTelemetry directly into node-wot to standardize telemetry collection; the Infrastructure Layer enhances Docker Compose configurations with health checks and observability backends; and the Monitoring Layer provides actionable insights through custom dashboards and alerts. Drawing from my experience with AWS services, Azure Monitor, and containerization technologies, I'm confident I can deliver a solution that addresses the unique challenges of IoT observability. I'm particularly excited about making distributed tracing work across different IoT protocols, as this will provide unprecedented visibility into cross-protocol interactions that are common in real-world IoT deployments while working with a team to deliver results!
Uyuni is the open-source upstream of SUSE Manager, a configuration and infrastructure management solution for administering multiple Linux systems. To ensure code quality, Uyuni employs two types of tests: 1. Continuous Integration Tests: These tests are run periodically on the master branch to catch breakages that have slipped through earlier testing. When these tests fail, developers must revisit older tasks, leading to frequent context switching and reduced productivity. 2. Pull Request Acceptance Tests: These tests are run on new pull requests to prevent breakages from reaching the master branch. They provide fast feedback to developers, helping them fix issues while they are still focused on their tasks. Currently, Pull Request Acceptance Tests execute most of the test suite, with an average runtime of one hour. This delays feedback for developers and increases infrastructure costs. This project aims to develop a machine learning model that, using past pull requests, test results, code coverage data, and other relevant information, predicts which small subset of tests is most likely to fail for a new pull request. Running only this smaller subset of tests will speed up developer feedback, reduce infrastructure costs, and maintain high test coverage. Inspired by Facebook's Predictive Test Selection paper, this project applies and extends its techniques to optimize Uyuni’s testing strategy and increase developer productivity.
CORE-V Wally is an open-source configurable RISC-V processor that belongs to the OpenHW Group suite of cores. It is also the guiding example for a textbook on RISC-V System on Chip Design, being written by the developers. Wally can be configured from a simple RV32E embedded core to an RV64GC application processor with caches, branch prediction, virtual memory, floating-point, and an array of peripherals. Wally presently is at Technical Readiness Level 4, passing the riscv-arch-test compatiblity suite and a set of custom directed tests. It boots Linux on an FPGA and in lock-step simulation checking against the ImperasDV reference model. It has about 90% code coverage, and functional coverage is not yet measured. The goal of this project is to bring Wally to Technology Readiness Level 5. This would be an excellent project for a mentee interested in computer architecture, logic verification, and logic design. This will entail: • Reviewing and improving the Wally SystemVerilog code base • Writing tests in RISC-V assembly language and/or C to bring Wally to 100% code coverage • Writing and improving scripts (e.g. in Python) to automate testing • Bringing up the ImperasISACOV functional coverage verification flow • Bringing up risc-dv or another random test generator • Creating coverage groups for architectural and microarchitectural features and developing random and directed test cases to bring functional coverage to 100%
As we plan to take the PSLab project to the next level, developing multiplatform support for the app and enhancing its communication capabilities are key to making PSLab more accessible and effective for students, educators, and science enthusiasts across diverse environments. Currently, the Pocket Science Lab (PSLab) mobile application is available only for Android, limiting its usability in institutions where iOS, desktop, or web platforms are widely used. This project aims to rebuild the existing Android app using Flutter, enabling support for Android, iOS, desktop (Windows, macOS, Linux), and web, all from a single codebase. Flutter’s flexibility and performance make it an ideal choice for this cross-platform transformation, ensuring a smooth user experience across all device types and screen sizes. Another crucial part of this project is enhancing the hardware communication layer to accommodate platform-specific constraints—particularly Apple’s restrictions on USB communication. To address this, the project will implement Wi-Fi-based connectivity using the ESP01 chip, allowing seamless data transfer between the app and the PSLab hardware across all platforms. This ensures that iOS and web users are no longer at a disadvantage and can fully utilize the PSLab instruments. By the end of the project, the app will offer a robust, real-time interface for core instruments like the Oscilloscope, Logic Analyzer, Multimeter, and Robot Controls, complete with interactive visualizations.
P4 empowers developers to program the data plane of network devices—switches, routers, and NICs—at a level of detail previously only accessible to hardware designers. P4 software/simulated switches like BMv2 make the development even easier by having the programs and control plane run on developers' computers and give instant feedback. This project aims to further improve the capability of BMv2 and enable a potentially broader insight for developers to analyze their P4 program. While traditionally one packet only goes through one path within the switch and thus obtains only one result, there are many situations where it is more useful to have all possible outputs from a P4 simulation. For example, we use this for diff testing, to determine whether the switch is doing something correct or something incorrect. Multiple allowed behaviors and results usually arise from various multi-path constructs (e.g. ECMP, WCMP, or perhaps LAGs) which are often modeled as action profiles/selector in P4. BMv2 currently allows users to set a mode determining action profile/selector behavior, like `round robin` where every time one sends in the same packet, it would invoke the next possible forwarding action (eventually wrapping around). The goal of this project is to provide a new mode for BMv2 to output all possible behaviors. This will both require extending the action profile modes, and extending the notion of output from a set of packets to a set of sets of packets.
My name is Edward. I'm a Master’s student at the University of Colorado Boulder in the US and I am passionate about Apache Fineract’s mission to improve the availability of financial services to people all over the world. Apache Fineract provides core banking APIs, but lacks a community-maintained layer for end-users. The former Self-Service API was removed, leaving vendors to build their own frontend from scratch. To support this new frontend, I am proposing a new Backend for Frontend (BFF) and associated frontend that enables improvements to end-user security, reliability, performance, and auditing. The focus of this project is to build a POC that is well-tested and documented so we can build a "release-ready" solution in the future. Deliverables include: 1) Standalone Spring Boot BFF application with its own user model and JWT-based authentication 2) Feign client integration with Fineract's core API via a dedicated service account 3) API Aggregations for User data summaries, account information, loan and savings views, and transaction capabilities 4) User registration flow with OTP and Identity Verification 5) User login flow with 2FA 6) Auditing for Basic Frontend Concerns 7) Open Banking Authentication Flow 8) A working frontend to demo these features Some stretch goals include but are not limited to: 1) MPIN for transaction authorization 2) Rate Limiting 3) HSM key storage
The current reuse workflow in FOSSology provides a powerful mechanism to copy license clearing decisions from a previously analyzed upload to a newer version. However, this process remains largely mechanical and opaque, offering little insight into what has changed between versions after reuse is applied. As a result, users must manually inspect differences to understand the impact of reuse, which becomes increasingly difficult for large codebases and frequent updates. To address this limitation, this project proposes the development of an Enhanced Reuser Agent that adds an intelligent analysis layer on top of the existing reuse workflow. The agent runs automatically after scanners complete and reuse decisions are applied, comparing the previously cleared upload (v1) with the new upload (v2). It generates insights such as a diff-aware file tree, license comparison, aggregated statistics, and a risk-level summary. In addition, a Smart Reuse (Suggested Matches) mechanism automatically identifies and recommends similar previously-cleared uploads, reducing the manual effort required to search for suitable reuse candidates. By providing a clear and interactive view of structural and license-level changes, along with proactive reuse suggestions, the system enables users to better understand the outcome of reuse and efficiently refine decisions where needed. This transforms reuse into a more transparent and insight-driven process, reducing manual effort and improving overall usability while remaining fully compatible with the existing FOSSology workflow.
FreeCAD comes with a Robot Workbench, which is capable of 6-DOF robot simulations, trajectory planning and a vendor specific code export (KUKA). After the removal of some copyrighted model assets and years without an active maintainer, the workbench is functional but difficult to use and customise. The robots can only be defined via hand-written VRML and CSV/DH files, the bundled kinematics library has lagged behind the latest upstream release, the axis count for robots is hard coded to six and the documentation for beginners is sparse. Thus this project proposes an incremental modernization of the existing “Mod/Robot” module: 1. Standardised robot imports : Unified Robot Description Format (URDF) is one of the most common standards for describing a robot. Having an easy way to import robots directly from URDF will replace the painful CSV/DH file imports. 2. Generic joint-trajectory export : Having the possibility to export the joint & trajectory data will separate the export process from copyrighted vendor-specific pipelines. The users can post-process the exported data to their specific platform 3. Kinematics library refresh : FreeCAD currently has a local fork of KDL library that lags behind the upstream. Cleaning up this dependency will eventually prepare the path for arbitrary-DOF robots & better robot animations. 4. Documentation : This will help the existing users as well as attract a new user base towards the Robotics Workbench.
Problem: Imbalanced datasets pose a significant challenge in machine learning, where standard metrics like accuracy can falsely evaluate a model that simply predicts the dominant class. Currently, the R community lacks a comprehensive and unified framework for handling imbalanced data and X-Risks problems natively integrated into the mlr3/mlr3torch ecosystem. Solution: This project, mlr3torchAUM, provides a comprehensive solution for imbalanced classification in R. It will bridge the current gap by integrating state-of-the-art loss functions, advanced evaluation metrics, and various data sampling techniques directly into the mlr3/mlr3torch pipeline. Deliverables: 1. State-of-the-Art Loss Functions: Implementation of algorithms including log-linear all-pairs squared hinge loss, Area Under Min (AUM) loss, and cost-sensitive logistic loss. 2. Sampling Operators: A robust suite of over-sampling techniques including SMOTE and ADASYN, alongside under-sampling techniques, all implemented safely under a `lazy_tensor` mechanism to avoid memory issues. 3. Advanced Evaluation Metrics: Integration of Precision-Recall curves, Macro/Micro AUM/AUC, and MCP/IMCP to fully support multiclass imbalanced scenarios. 4. LibAUC Integration: Porting cutting-edge losses and optimizers from the Python LibAUC library into R. 5. Engineering & Release: Comprehensive Test Driven Development, GitHub Actions for CI/CD, detailed vignettes, and a final submission to CRAN.
The RISC-V movement has massive potential to unify a fragmented industry behind a single instruction set architecture (ISA). If the participants in the industry can agree to focus their efforts on a single processor architecture, rather than duplicating efforts among incompatible architectures, the entire computing ecosystem benefits. Inefficiency in critical base components of the ecosystem hampers this consolidation. There are separate efforts in documenting the RISC-V ISA, succinctly describing the semantics of the ISA in the RISC-V Sail implementation, and the numerous projects which directly serve as the base components of the software ecosystem, including assemblers, disassemblers, compilers, linkers, loaders, simulators, emulators. In summary, the tasks in this project will include: Improving the RISC-V Sail specification. (Sail language, git/GitHub) Improving the Sail parser’s JSON backend to extract more complete and accurate information. (OCaml, git/GitHub) Improving the RISC-V ISA interactive web site with new functionality and information. (Javascript, React, Carbon, or similar web frameworks, git/GitHub) Survey downstream projects which have dependencies on the RISC-V ISA. (C, C++, RISC-V assembly) Implement transformations of RISC-V ISA representation in JSON into downstream project content. (Python or similar, C, C++, RISC-V assembly) Engage with upstream projects (Sail, RISC-V Sail specification) to submit change proposals and see that they become acceptable.
<p><strong>Hibernate Search</strong> is an extension to Hibernate ORM that brings the powers of full-text search via <a href="https://lucene.apache.org" target="_blank">Lucene</a> and <a href="https://www.elastic.co" target="_blank">Elasticsearch</a> to JPA models. Think of it as Google: after processing the input keywords (e.g. ignoring stop words and applying different kinds of normalization), Hibernate Search returns results ordered by relevance. It brings significant benefits comparing to normal SQL for search-related uses cases. Its full-text index can be updated in two ways: Automatically, whenever data changes (using listeners hooked into Hibernate) or by means of the "mass indexe", which rebuilds the entire index for given entity types.</p> <p><strong>This proposal aims to provide an alternative to the current mass indexer</strong>, based on the Java Batch architecture as defined by <a href="https://jcp.org/en/jsr/detail?id=352" target="_blank">JSR 352</a>. This standardized tool <a href="https://jcp.org/en/jsr/detail?id=352" target="_blank">JSR 352</a> provides task-and-chunk oriented processing, parallel execution and many other optimization features. This batch job should accept the entity type(s) to re-index as an input, load the relevant entities from the database and rebuild the full-text index from these.</p>
This project aims to introduce a scalable and maintainable internationalization (i18n) system for applications built using MIT App Inventor. Currently, App Inventor does not provide a structured approach for handling multi-language support, making it difficult for developers to create globally accessible apps. The proposed solution introduces a key-based translation system that decouples user-visible text from UI components. The system integrates across multiple layers of App Inventor, including the Designer, Blockly, runtime, and build system, enabling automatic translation handling in generated applications. Key features include: - Automatic detection of user-visible text from component properties and Blockly blocks - A centralized translation editor for managing multi-language content - Context-based key generation to ensure stability and avoid ambiguity - Runtime translation using JSON for flexibility during development (Companion) - Build-time generation of native Android/iOS resources for efficient production builds The system is designed to be fully backward compatible and supports progressive adoption, allowing existing projects to continue working while enabling developers to gradually migrate to the new translation model. Deliverables include: - A working runtime translation system for App Inventor apps - Integration with Blockly for key-based text handling - Designer-level synchronization and key management - Build-time resource generation for native localization - End-to-end tested implementation with documentation
Forest fires in the boreal regions, particularly in Alaska, result in significant losses, ranging from loss of life to environmental degradation and disruption of essential services. Detecting and tracking these fires swiftly and accurately is crucial for effective rescue operations and resilience planning. This project seeks to develop precise metrics for assessing the severity and intensity of forest fires, enabling better management strategies. Introducing a novel approach where video frames are simultaneously passed through two methods: the first method focuses on detecting fire spots and accurately estimating the area of fire spread using bounding boxes and fire pixel analysis. The second method analyzes the direction and speed of the fire spread by calculating optical flow vectors. Forest rangers will receive actionable insights in real-time, including the area, direction and speed of fire spread, along with the count and location of fire spots, the distance between spots, and alarm functionalities to facilitate quick decision-making. These insights will be geo-referenced using drone flight data, providing accurate coordinates for targeted intervention and containment efforts. Set of Deliverables: - An optimized fire detection model capable of accurately identifying fire spots. - Parameters and algorithms for calculating severity based on fire detection data. - A comprehensive system for providing real-time actionable insights to forest rangers, enabling them to make informed decisions and respond promptly to forest fire incidents.
Direct interoperability between molecular dynamics software is critical for enabling collaboration, data transfer and easy use by scientists. OpenBabel is a popular toolbox for chemical molecular modelling as it enables searching, conversions, analysis and data storage. The ability to interconvert chemical file formats with OpenBabel, in particular, opens up the ability to utilise and work with other packages, as OpenBabel enables input and writing of over 100 chemical data file formats. Therefore, expanding to OpenBabel will hugely increase the ability of MDAnalysis to handle a variety of data formats and encourage greater adoption of MDAnalysis as an “all-in-one” package for molecular dynamics analysis. The converters already established in the MDAnalysis package for OpenMM, ParmED and RDKit either read coordinate files into their respective objects before using them to create a MDAnalysis Universe or convert Universes in the reverse direction. I plan to take a similar approach to these existing converters. I will utilise OpenBabel Python bindings to make my task of introducing interoperability much easier, since Python code in the MDAnalysis package can easily access OpenBabel attributes (as long as the user has installed OpenBabel in an appropriate directory). I will start with conversion of MDAnalysis AtomGroup objects to OpenBabel OBMol objects, then work on conversion in the reverse direction. This means access to alternative formats and file type export options will be prioritised. Then, I will create a second converter file to convert OpenBabel OBMols to MDAnalysis Topologies, or adds them to a pre-existing Topology.
TARDIS generates synthetic observations of stellar explosions that can be compared to real observations. With such comparisons, we can learn more about the physical processes occurring and the conditions inside the supernova, including which elements and atomic transitions are dominant. TARDIS tracks the atomic transitions of interacting photons, level populations, etc. allowing the user to interrogate the physical conditions of the supernova. The goal of this project is to build a visual tool to represent this information for the user in Grotrian diagrams, which show different atomic levels of ions and transitions between them. Developing this tool will allow the user to more easily understand the important physical conditions of their supernova model. A regular Grotrian diagram would only display the overall line interaction for the packets that interact with the ion, but we also want to display how many packets went through each specific transition and the level populations. One way it could be done is to color each arrow to represent quantity of packets (similar to a heatmap) and the thickness of the level platforms denoting the level populations. This project will have the following deliverables: - Develop an interactive widget which allows the user to look at the Grotrian diagram for specific ions which interacted with photon packets during a TARDIS simulation. - The widget should allow the user to filter on a wavelength range, type of line interaction (excitation or de-excitation), and ion. The diagram will also give a sense of the frequency of each line transition using colors. - Develop the above plot as a static Matplotlib too. - Integrate this widget into TARDIS codebase and documentation. - Create a Jupyter notebook tutorial for the tool.
The mediapipe-rs project provides a Rust SDK to support mediapipe AI models. The SDK provides utility functions to pre-process application data (such as images, audio and video) into TFLite / PyTorch formats, and convert the inference results back into application data. In order to accomplish this, the [mediapipe-rs](https://github.com/WasmEdge/mediapipe-rs) project has made extensive use of the [ffmpeg](https://www.ffmpeg.org/) library. It [compiles ffmpeg to Wasm](https://github.com/WasmEdge/mediapipe-rs/blob/main/src/build.rs) and then builds it together with the application binary. However, the issue with this approach is that those Wasm-compiled ffmpeg functions are slow. We believe a better approach is to create a ffmpeg plugin for WasmEdge, and allow Wasm applications to call native ffmpeg functions as host functions. - Expected Outcome: - The deliverables will be - A WasmEdge plugin for ffmpeg that is similar to the [WasmEdge OpenCV-mini plugin](https://github.com/WasmEdge/WasmEdge/tree/master/plugins/wasmedge_opencvmini). That is to re-export ffmpeg functions in C style as plugin functions as covered in the [plugin developer guide](https://wasmedge.org/docs/category/wasmedge-plugin-system). - A Rust SDK for Wasm programs to access ffmpeg functions in the plugin. Similar to the [WasmEdge OpenCV-mini SDK](https://github.com/second-state/opencvmini) - Refactor the mediapipe-rs project to use the ffmpeg plugin
ArviZ is a package for the exploratory analysis of bayesian inference models. The current Python release of ArviZ involves three major modules that also encapsulate its core functionalities- data, plots, and stats. These are planned to be split into packages of their own, like arviz-plots, arviz-base, and arviz-stats. Development work involving the creation of these is being undertaken, with some key refactoring changes especially planned for the arviz-plots based plotting functionality, which is what this project is based on. The current plots that Arviz supports were added incrementally to the package over time, including in past GSoC projects, resulting in some redundancy and complicated to extend code. Plans and brainstorming for refactoring this have been around for a while. Work done so far on ArviZ-Plots has included a new class, PlotCollection, an improved backend interface and backend system, and 4 “batteries-included” plots at least partially adapted for this new backend. For my role in the course of this project, I will be using the PlotCollection class to implement some other plots from old ArviZ and add modular backend functions and visual elements (an intermediate layer for atomic visual elements used across plot types) required for these as appropriate. I will also be working on creating documentation and tests for these new plots added to ArviZ-plots as well as the PlotCollection class used to do these. For users, the refactored changes aim to provide improved visual aesthetics, an abstraction of aesthetics mapping to subplots and a more compact, flexible API overall. For developers, easier writing of new plotting functionality, extensibility and maintainability are the goals.
"Following the ratification of RVV specification, the software simulation framework and RTL designs for RVV have been released. Given the complexity of RVV design and the combinations of its configuration, both developers and users need a golden test suite to verify the correctness of the respective RVV implementations and simulations. RIOS lab thus introduces this project and contributes to RISC-V foundation. In this project, you will be designing a RVV test generator to help verify the functionality of either simulator or ASIC design of RISC-V vector processors. This project has two phases. In the first phase, we will write the a constant test suite generator for RVV that automatically produces the same test streams given a fixed RVV configuration. This would help debug and ensure reproducibility needed by developers. While in phase 2, we will extend the test generator to produce random vector test to cover the corner case of the RVV design. RVV Spec: https://github.com/riscv/riscv-v-spec RISC-V CTG: https://github.com/riscv-software-src/riscv-ctg RISCOF: https://github.com/riscv-software-src/riscof RISCOF Documentation: https://riscof.readthedocs.io/en/latest/intro.html Learning Objectives: 1. RVV instruction set architecture 2. How does vector processor work? 3. Formal Verification of RVV 4. Test generation and verification model 5. Design of advanced random test generation framework
The OWASP Agent - Module C: The Librarian (OpenCRE) project makes it possible to use continuously changing OWASP guidance inside OpenCRE, while keeping the OpenCRE graph trustworthy. OpenCRE already links stable standards well, but mapping “living” OWASP content at scale is still manual and can introduce mistakes. Module C becomes the decision boundary: it determines when a new section should automatically map to a CRE node, when an existing mapping should be updated, and when the case is uncertain and must go to human review. The Librarian follows an explicit-link-first workflow and uses a semantic fallback that retrieves the top 20 candidate CRE nodes with pgvector, reranks them with a sentence-transformers cross-encoder (ms-marco-MiniLM-L-6-v2), and applies safeguards such as negation handling, update detection, and contradiction checks. Only results scoring above 0.8 are written automatically; the rest are routed to a review queue. Deliverables include a production-ready Module C pipeline integrated with OpenCRE, a golden dataset and reproducible evaluation harness, CI regression gates to prevent quality drift, and operational documentation for calibration and maintenance. If time permits, I will also prototype hybrid retrieval (vector + BM25) for identifier-heavy cases and a lightweight human review dashboard (Module D). By the end of GSoC, OpenCRE will have a measurable, safe mapping layer that enables Project OIE to ingest OWASP knowledge without sacrificing trust.
The current Wagtail news starter template presents significant onboarding challenges for new developers, including dependency conflicts, Python version incompatibilities, lack of cross-platform setup support, and incomplete features such as a non-functional newsletter and missing RSS feed. This project aims to transform the starter template into a reliable, modern, and beginner-friendly entry point into the Wagtail ecosystem. The approach is structured across three pillars: 1. Stabilization: Introduce CI targeting the latest stable versions, resolve dependency conflicts, enforce reproducible installations, and implement a cross-platform setup system using a single Python entry point validated via CI on both Linux and Windows. 2. Modernization: Replace broken or missing features with Wagtail-native implementations, including a working newsletter (FormPage), RSS feed, improved admin interfaces (PageListingViewSet, SnippetViewSet), SEO fixes, modular StreamField block architecture, and GDPR-compliant asset handling. 3. Developer Experience: Improve onboarding through interactive admin guidance, simplified frontend tooling, better inline documentation, and demo content that works out-of-the-box. Deliverables include a fully functional, CI-validated starter template, modular and reusable architecture, improved documentation, and a setup experience that reduces time from clone to running project to under five minutes. Initial validation experiments show a 100% setup success rate in controlled environments with zero dependency conflicts, demonstrating feasibility.