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.
"The evolution of KVM (Kernel-based Virtual Machine) unit tests from a virtualization testing framework to one that also encompasses bare metal testing allows us to build a comprehensive unit test framework for Supervisor Binary Interface(SBI) in RISC-V. The need for a standalone, comprehensive unit test framework for SBI has become increasingly evident. Validation of the SBI specification has traditionally been intertwined with feature implementations across OpenSBI, KVM, and the Linux kernel. By establishing a dedicated unit test framework, we aim to streamline the identification and rectification of bugs early in the development cycle, thereby ensuring a robust and reliable specification for RISC-V's growing ecosystem. The RISC-V support along with a few SBI extensions got merged[1] recently, which enabled basic SBI extensions and SMP/EFI support in kvm-unit-tests for RISC-V. Expanding the coverage of both existing and forthcoming SBI extensions is critical to accelerating the development and adoption of the SBI specification. Besides generally improving kvm-unit-tests, tests for the following SBI extensions may be added: SBI PMU support Bare Metal testing using OpenSBI firmware Virtualization testing with KVM SBI Steal time extension support Virtualization testing with KVM SBI Debug Trigger extension Bare Metal testing using OpenSBI firmware Virtualization testing with KVM Any other extensions (SUSP, MPXY ?) CoVE related tests (time permitting)
<p>DCE currently makes use of net-next-nuse to extend the Linux kernel internals like the networking stack to host applications but over the years the project hasn't been updated with the latest releases of the Linux kernel. This project aims at enabling support for latest Linux kernel features and toolchains in the DCE environment with support for the socket networking stack, sysctl interfaces, system call access, etc. without any changes to the user APIs currently being used by host applications.</p>
<p>Real-world data generating processes often don't produce normally-distributed data, in particular the skewness/kurtosis/tail index parameters are inconsistent with a Gaussian random variable. If we can "Gaussianize" data from such processes in a meaningful way, then we can make better inferences. We can solve this problem generally by applying a Lambert W transform (Goerg, 2014), which assumes the observed data is distributed as Lambert W x F_X, where F_X is the distribution of the latent input (Goerg , 2011). To apply this transform, we need to estimate parameters of the Lambert W x F_X distribution and also support the inverse transform, so that we can make inferences about the latent input. With this project, we want to support Lambert W x F_X distribution in Stan in an inferential setting, which means: users can build Gaussian models over non-normal data in a transparent way.</p>
The state of Julia GPU support ranges from “very good” (CUDA.jl) to “on the way” (Metal.jl). Recently, the shared high-level interface GPUArrays.jl added support for KernelAbstractions.jl, which defines a common interface that can be used to write optimized kernel implementations once for all the downstream vendor-specific GPU packages such as CUDA.jl, AMDGPU.jl, Metal.jl, and oneAPI.jl. However, most optimized kernel implementations still live in the vendor-specific package they were written for, leaving the other packages to either reimplement their own version, use the current unoptimized fallback implementation from GPUArrays.jl, or in many cases, the operation is not supported. This project aims to rewrite these optimized operations in GPUArrays.jl using the KernelAbstractions interface to improve performance and functionality for all GPU backends at once. The end result being that users of the less mature backends will benefit from more functionality, as well as increasing the impact of future contributions for all users of the JuliaGPU ecosystem.
DataLoom is a browser-based data wrangling workspace that enables users to upload tabular datasets, apply reversible transformations, and manage data visually without writing code, supported by a checkpoint and revert system. Currently at the MVP stage, DataLoom supports only CSV files and lacks key capabilities such as data profiling, visualization, dataset merging, and efficient column selection. This project expands DataLoom into a full data preparation platform by introducing multi-format ingestion, automated data profiling, dataset joins and concatenation, formula-based transformations, reusable pipelines, interactive visualizations, and an automated data quality engine with scoring and one-click fixes. It also adds multi-format export and downloadable reports. Key deliverables include multi-format ingestion and export, a profiling API with a reusable column selector, join and merge operations, a visualization panel, a data quality engine, a formula editor, reusable pipelines, downloadable reports, a full frontend TypeScript migration, a refactored backend, comprehensive testing, and a redesigned scalable UI. The outcome is a robust, end-to-end data preparation tool that supports the complete workflow from raw data ingestion to cleaned, analyzed, and export-ready datasets.
The goal of this project is to get syzkaller, a coverage-guided OS kernel fuzzer, working under FreeBSD/RISC-V. As syzkaller is written mostly in Go, the first step is to ensure that Go is able to compile syzkaller. Previous work can be harnessed from two projects to make this tractable. First, Go has a RISC-V port targeting GNU/Linux, and second, the CHERI project has a FreeBSD/mips port of Go. The next step is to add FreeBSD/RISC-V support to syzkaller itself. A work-in-progress patch for FreeBSD/arm64 support can be used as a template. Two bonus tasks are: 1. upstream Go support for FreeBSD/RISC-V to the Go Project, and 2. begin fuzzing system calls under FreeBSD/RISC-V. Syzkaller is flexible enough to target OS interfaces other than system calls. For example, it has been used to fuzz the Linux USB stack and has found dozens of bugs in the USB subsystem alone. The details are complicated, but the idea is simple. 1. Generate a program, which invokes one or more system calls. 2. Run the generated program. 3. Check to see if the system diagnosed an error. - If not, collect kernel code coverage information and decide whether to try iterating upon the previous test program, or start anew. - If so, collect information about the crash and try to discover a minimal test case that triggers the crash. The mentors will have weekly meetings with the mentee to discuss progress and strategies for overcoming any challenges.
The Doodle library for compositional vector graphics can be further improved by adding support for coordinate planes, the grid, legend, labels and titles, including the x-axis label, y-axis label, and plot title, which will simplify graph analysis. With the support of my mentor and the community, I will implement the plotting functionality in Doodle, improving the ability to visualize, compare and explore data. Moreover, the improved plotting capabilities will make the presented data easier to understand and more accessible to a wide audience. The project itself can be divided into three separate deliverables: 1) Plotting API: it’s necessary to define a plotting API that will allow users to create various plots, customize them, and perform data transformations. The API should be flexible and extensible, allowing users to easily add new types of plots, customize the appearance and layout, and apply different data transformations. To achieve these goals, we will use the tagless final style and composition, which enables us to combine multiple interfaces. 2) Graph Adjustments Support: these features can help improve the clarity and usefulness of the plots and graphs we create. These features include axis limits, line width, marker style, transparency, color scheme, legends, annotations, axis scale, aspect ratio, etc. 3) Documentation: in addition to written documentation, we will provide visual examples and demos that are extremely helpful in illustrating how to use the API. Providing code snippets and sample plots will help users get started quickly and provide a foundation for more advanced usage.
<p>Netlink is a network protocol that is used to communicate between the kernel and the userspace. For example, iproute use netlink in order to configure the network stack (interfaces, addresses, routes, etc). It is also used by the kernel to report hotplug events to the userland. The goal here is to add support in strace to decode netlink packet structures in order to be able to debug and discover netlink messages.</p> <p>In 2016, the base ground work was done, now it can be extended to support more netlink family protocols.</p>
The program aims to leverage agents built using publicly available large language models (LLMs) and personalize them with Retrieval-Augmented Generation (RAG). This approach creates various levels of agentic roles to transform mainframe workloads and modernize them at every phase, from discovery and design to transformation, testing, and deployment. Problems to be addressed in the project: - Unavailability of application documentation. - Lack of comprehensive view of all tasks to be included in the transformation plan. - Multiple iterations of Code conversions. - Technical and resources dependencies. - Unavailability of Application support for the transformation. Deliverables: - Working Agents which will build a program plan at each of the modernization phase for all workstreams. - Agents performing Code transformation with minimal effort from migration team. - Agents performing application analysis with less dependency from application teams.
[Problem] The project aims to enhance the runtime performance of OpenVINO on RISC-V devices to fully leverage their power efficiency for running DL/AI workloads efficiently. [Methodology] This will be achieved through three key optimization strategies: adopting or improving third-party libraries with RISC-V optimized primitives, porting existing x86/ARM optimized kernels to RISC-V ISA, and implementing device-specific transformation passes tailored for RISC-V backend optimizations. [Deliverables] The project will deliver: 1. Adoption of optimized RISC-V kernels from third-party libraries for more operations in OpenVINO. 2. Porting of critical x86/ARM optimizations to RISC-V ISA. 3. Implementation of device-specific transformation passes for RISC-V backend requirements. 4. Demonstrated improvement in OpenVINO runtime performance on RISC-V CPU devices through benchmarking against determined workloads.
FHIR resources are powerful but difficult to explore in practice because their data is deeply nested, inconsistent across resource types, and hard to analyze in raw JSON form. This project will enhance the existing FHIR Resource Tabular Viewer to make healthcare data easier to search, filter, and interpret for researchers, clinicians, and developers. I will improve the transformation layer that maps nested FHIR structures into stable, readable table columns, strengthen exploration features (global search, column filters, sorting, column visibility, and row-level drill-down), and extend ingestion support to additional sources, specifically local files and Amazon S3. Key deliverables are: (1) an improved and more reliable FHIR-to-table transformation pipeline for common resource types (2) upgraded table exploration and visualization workflows (3) modular data-source support for local and S3-backed datasets (4) performance improvements for larger datasets (5) expanded automated tests and documentation. The final outcome will be a more scalable, maintainable, and user-friendly viewer for real-world FHIR data exploration.
<p>Distance fields looks similar to rasterized images but are very different from them. In the context of fonts, each pixel in a distance field image (or bitmap) is a shortest value from that pixel's position to the nearest edge of the outline of the corresponding glyph. Distance field is also known as distance transform and have various applications such as image processing, path-finding etc, but the main motive behind this project is to support high quality text rendering in real-time graphics applications (such as games). So, while rendering distance fields in such applications, the renderer can simply check the pixel's value and discard ones that are greater than a specific range. This makes distance fields almost infinity scalable without losing quality, this means you can use a 128x128 resolution distance transform and it will provide better quality than a 4k resolution image and will also require much less space. Moreover they can also be used to add many types of cool effects, like halos, drop shadows, bluring etc. So, the goal of this project is to add support for generating signed distance fields from font files in FreeType.</p>
kornia-rs currently supports only CPU-based computation for image processing operations like resize, warp, and color transforms. This project implements a GPU backend for kornia-tensor and kornia-imgproc, motivated by a concrete Bubbaloop use case: a real-time camera pipeline that needs faster preprocessing to make VLM inference feasible on edge hardware. The work includes a feature-gated GpuAllocator with explicit host-device transfer semantics, allocator-based backend dispatch for tensor operations, and GPU kernels for resize, warp_affine, warp_perspective, and RGB <-> Grayscale conversion using CubeCL.
<p>The project aims at dealing with the conversion of <strong>CiceroMark to DOCX (OOXML) and vice versa</strong>. In the first portion, we are gonna improve the add-in by improving the existing features and addition of new features which generally includes the ergo expressions and inline blocks of a template. Apart from these, there will be testing of data to ensure that the correct data is entered into the variable fields to avoid any inconsistency. The second portion involves the conversion of the <strong>OOXML to CiceroMark</strong>. In this, improvements will be made to the OOXML transformer present <a href="https://github.com/accordproject/markdown-transform/tree/algoo-ooxml" target="_blank">here</a>. The current transformer works only for very basic OOXML. We need to extend the functionalities of the transformer to support more ciceromark and commonmark classes like lists, optional, inline, ergo formula blocks. In this way, we will ensure more flexibility and portability with the round trip transformation of the smart clause templates.</p>
<p>Julia is a dynamic programming language that, over the past few years, gained interest in the open-source community, especially in the field of scientific computing. Julia programs are executed by a virtual machine that translates the source code, during run-time, to machine code based on the LLVM compiler framework. LLVM provides a variety of analyses and transformation capabilities that are leveraged to optimize programs and facilitate efficient execution. More recently, LLVM was enhanced by a new optimization framework, namely Polly, that supports automatic parallelization and data-locality optimizations based on the polyhedral model. Polly is able to speed up compute kernels significantly, especially in the context of dense linear algebra and iterative stencil computations. In the course of this project I plan to integrate Polly into Julia to enable polyhedral optimizations for Julia programs.</p>
The torchvision package in the mlverse ecosystem provides essential tools for computer vision workflows in R, including datasets, transformations, and model utilities. While the ecosystem has matured significantly, a key limitation remains in the performance of certain core operations, particularly in detection pipelines. Functions such as Non-Maximum Suppression, bounding box transformations, and proposal filtering are currently implemented at the R level, which introduces inefficiencies when working with larger inputs or real-time use cases. This project aims to address that gap by moving performance-critical components into a native C++ backend using torchvisionlib. The approach will focus on identifying the parts of the pipeline that are actual bottlenecks, implementing them in C++ with careful attention to memory usage and batching, and integrating them back into torchvision without changing the user-facing API. Rather than rewriting everything, the work will prioritise targeted optimisations that have a measurable impact on end-to-end performance. In addition to backend improvements, the project will include the implementation of at least one modern computer vision model family, such as YOLO, using the optimised components. If time permits, support for an additional model (e.g., RT-DETR) will also be explored. These models will be integrated into the existing ecosystem with consistent APIs and working examples. The main deliverables of this project are: a set of optimised C++ implementations for core detection operations, their seamless integration into torchvision, at least one fully functional model pipeline built on top of this backend, and supporting documentation and benchmarks demonstrating performance improvements. The goal is to make torchvision not just feature-complete, but efficient enough for practical, large-scale use.
<p>For the past several years 360° cameras have become far more accessible, and several video-sharing services enabled support for 360° videos (for example, YouTube and Facebook). Nevertheless, FFmpeg currently doesn’t support any of 360° video formats.</p> <p>The goal of the project is to write a filter which will be supporting conversation between various 360° video formats. A filter should also support all basic 360° transformations: rotations (roll/yaw/pitch), Field of View extraction, etc.</p>
This project will enhance FOSSology's license intelligence stack by revamping both Nirjas and Atarashi into a faster, ML-driven, and language-aware pipeline. Nirjas will move from regex-oriented parsing to a Tree-sitter architecture with language packs across 248 languages, improving comment extraction fidelity in real repositories. Atarashi will be upgraded from broad full-file matching toward retrieval-plus-classification that emphasizes high-signal fragments, because keywords matter for license intent (for example, phrases like permission grant, redistribution, warranty disclaimer, copyleft, and patent terms are often decisive). To support both components, I have already upgraded the Minerva dataset pipeline to generate train/validation/test datasets for Nirjas and Atarashi using merged inputs from ScanCode LicenseDB, FOSSology licenseRef.json endpoint, and The Stack Smol comment corpus, followed by augmentation, LLM-generated hard-negative synthesis, and near-dedup. A sample dataset for benchmarking and integration testing is ready, while the full-scale dataset build is in progress. For modeling, Nirjas will use a model2vec classifier distilled from strong sentence-transformer teachers selected using MTEB/RTEB task performance together with our internal evaluations; the same model2vec distillation path is also planned for Atarashi, with a fine-tuned quantized embedding baseline retained as a fallback depending on speed/accuracy trade-offs. The expected outcome is a production-ready path to more accurate, scalable, and maintainable license detection across diverse codebases.
In this project, we aim to build a Rust-based log processing framework. Applications built on this framework will be compiled into WebAssembly and run in WasmEdge containers side by side with Linux containers and apps. The WasmEdge app collects logs from other containerized apps and then sends them to a streaming database or processing pipeline. - Expected outcome: * Create a Rust framework with 3 traits similar to the [`Transformer`](https://github.com/second-state/MEGA/blob/main/mega_etl/src/lib.rs#L99) trait in the [MEGA framework](https://github.com/second-state/MEGA). * The `Collector` trait abstracts operations needed for a log collector. * The `Transformer` trait abstracts the transformation algorithms that can be applied to the logs. * The `Destination` trait abstracts operations needed to send transformed to a streaming data pipeline or database. * Implement at least two `Collector`s. One for MySQL database binlog and the other for a generic log file in a Linux container in the same Kubernetes pod. * Implement at least two `Transformer` algorithms supported by [FileBeat](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html). * Implement at least three `Destination`s. One for a Kafka queue, one for a Redis database, and the other for ElasticSearch. * Provide CI and demo test cases. * Provide documentation and tutorials.
<p>This project aims to optimize the WebAssembly version of OpenCV.js. Some evaluation experiments have shown that current WASM SIMD version has some problems, e.g. low performance of the kernel cvtColor and resize. The goals of this project can be summrized like the following points:</p> <ol> <li>Make OpenCV.js support 64-bit intrinsics. </li> <li>Fix the low performance of cvtColor and resize kernels.</li> <li>Optimize the perf tests for kernels to have better code reuse.</li> <li>Do perf tests for more kernels of module imgproc, dnn, and objectdetect, e.g. Sobel, Scharr, blur, and so on.</li> <li>Create a detector in OpenCV.js to check the ability of SIMD on the browser, and create a loader to load the corresponding version of OpenCV.js: Normal version, or WASM version.</li> </ol>
Problem: IP cameras are frequent targets for cyberattacks due to their widespread use and often weak security. Current honeypots like SweetCam lack comprehensive protocol support and realistic emulation, limiting their effectiveness in detecting and analyzing threats. Solution: This project aims to transform SweetCam into a versatile, multi-protocol honeypot by: 1. Expanding protocol support for RTSP and ONVIF, enabling deeper interaction with attackers. 2. Introducing template-based device emulation using YAML to simulate real-world cameras (e.g., Dahua, Hikvision). 3. Improving usability with Docker enhancements, automated configuration, and a realistic HTTP interface featuring error simulation and multi-language support. Deliverables: 1. A production-ready SweetCam with RTSP/ONVIF support and 5+ device templates. 2. Optimized Docker deployment (multi-stage builds, Compose profiles). 3. Enhanced HTTP interface (login flows, error simulation, i18n). 4. Comprehensive documentation, including setup guides and protocol specifications. Impact: This upgrade will equip researchers and defenders with a powerful tool to study attacker behavior, improve IoT security, and contribute to the broader honeypot ecosystem.
Problem: gprMax's devel branch GPU solver (cuda_opencl/ directory) supports CUDA, OpenCL, and Metal via shared kernel templates. But the Plane Wave (TF/SF) source from GSoC 2023 remains CPU-only Cython, forcing CPU-GPU transfers every timestep that negate GPU speedup. solution: I will create new kernel templates in cuda_opencl/ following the existing multi-backend pattern: 1) Create knl_planewave_updates.py: batched kernel updating all six 1D DPW auxiliary arrays in one launch. 2) Create knl_tfsf_injection.py: TF/SF correction injection at six boundary faces, coalescing optimized per-face with shared memory buffers. 3) Optimize boundary storage: SoA layout, 128-byte padding, precomputed index maps. 4) Testing suite: GPU vs Cython comparison across free-space, slab, oblique, and polarization cases. Why me : I built a PyCUDA heat diffusion solver with shared memory tiling, vectorized loads, and occupancy tuning, the same techniques this project needs. I have raised 8+ issues and multiple PRs to gprMax and studied all 13 files in cuda_opencl/ in depth. Deliverables: multi-backend GPU kernels for DPW update and TF/SF injection, optimized memory layout, and automated testing suite. Outcome: TF/SF runs entirely on GPU, zero CPU fallback.
CircuitVerse provides a powerful digital logic simulator, but its classroom workflow lacks critical features required for effective teaching at scale. Currently, instructors cannot organize students into structured teams, assign collaborative work, reuse pre-built circuit templates, or rely on modern LMS integrations due to outdated LTI 1.1 support. These limitations lead to inefficient grading, repeated manual setup, and poor integration with platforms like Canvas. This project aims to enhance CircuitVerse’s classroom ecosystem by introducing four key improvements. First, a subgroup system will enable instructors to divide students into teams with defined roles, supporting structured collaboration. Second, group-based assignment workflows will allow submissions on behalf of a team, ensuring consistent grading and reducing redundancy. Third, a circuit template library with integrated test cases will enable reusable, pre-configured assignments and automated grading using a simulation-based evaluation pipeline. Finally, the project will upgrade LMS integration by implementing LTI 1.3 using OpenID Connect and OAuth 2.0, enabling secure authentication, deep linking, and modern grade passback via Assignment and Grade Services (AGS). The deliverables include: A fully functional subgroup and team management system with API support Group assignment workflows with submit-on-behalf functionality A template library with auto-grading using simulation-based test cases Complete LTI 1.3 integration including OIDC login, deep linking, AGS score submission, and NRPS roster access Comprehensive RSpec test coverage and documentation By addressing these gaps, this project will transform CircuitVerse into a scalable, LMS-integrated teaching platform capable of supporting modern classroom workflows and institutional requirements
<p>Netlink is, basically, an API used to transfer information between kernel and user-space processes. It consists on a standard sockets-based interface for user-space processes and an internal kernel API for kernel modules. The general idea would be to add netlink messages parsing support in strace. It could be very useful for network debug or tracing.</p> <p>After this work, more netlink family protocols can be added (NETLINK_ROUTE, NETLINK_FIREWALL ...).</p>