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 swift-java interoperability library provides the jextract-swift tool, which extracts Java sources that are used to call Swift code from Java. However, the tool uses the Foreign Function and Memory API (FFM), which requires JDK 22+, making it unavailable on platforms such as Android. The goal of this proposal is to extend the jextract-swift tool, such that it is able to generate Java sources using JNI instead of FFM and thereby allowing more platforms to utilize Swift/Java interoperability. The solution will modify the code generation to support multiple modes through a protocol. Thereby, allowing us to generate JNI Java wrappers that that utilize the JNI functionality already defined in the library. We will modify the current Arena implementations to support memory management for JNI as well, through calls to the Swift runtime. The library will also generate Swift thunks that implement the native methods defined in Java and handle JNI/Swift conversion and object initialization. The project will achieve feature parity with the current FFM mode and explore more complex language features, if time permits.
With today's dynamic technology , people interact more with their phones and tablets and in order to adapt with this change , PWAs offer a great solution with their ability to leverage the resource of a website and provide a cross platform experience on any device with almost all features a mobile app has to offer , like push notifications etc. One of essential prerequisites for PWAs is good integration of the web app in various resolutions. Submitty already has good support for most of it’s web features on mobiles and tablets and I would like to carry the work forward in the assimilation of more of its features and webpages in variety of display resolutions. With this done we can experiment and analyze various platforms in order to successfully implement the creation and maintenance of PWA for submitty , this will include exploring a platform that provides best support for all feature on variety of devices in the most optimal way. After we are done with selection , work on essential components like Manifest, Service worker , Caching and fetching of the assets, Optimal UI/UX for installation and other features could we worked upon. Then the work on some errors and compatibility issues could be done. Atlast the proper documentation for all the work including the usage , installation etc could be done.
The Volcano community introduced JobFlow to address inter-job dependencies. Through the concepts of JobTemplate and JobFlow, users can declare and orchestrate multiple Volcano jobs, leveraging control flow primitives such as sequential, parallel, conditional, branching, and looping execution. JobFlow aims to facilitate the migration of AI, BigData, and HPC workloads to the cloud-native environment. The current JobFlow functionality requires further enhancements to meet more complex real-world scenarios. Ref: https://github.com/volcano-sh/volcano/tree/master/docs/design/jobflow. Expected Outcome: 1. Support modifying parameters of a JobTemplate when referenced in a JobFlow, for example, changing container image versions, adjusting resource limits, etc. 2. Implement a configurable retry mechanism for failed jobs within a JobFlow, for example, supporting exponential backoff retry policies, setting maximum retry attempts, etc. 3. Introduce richer control flow statements such as if, switch, and for statements, for example, conditional branching based on the status of upstream tasks, iterative execution of specific task sets, etc.
<p>The Simple Feature Access Specification (aka. Simple Features) is a common standard for exchanging spatial features that is widely used in geoinformatics in Open Source projects as well as in proprietary programs. It defines a generic data model for storing and accessing geographic data and their geometry types.</p> <p>Protocol Buffers is a format for data serialization which has inbuilt features such as binary serialization, RPC frameworks and IDL. Its unique features such as flexible, efficient, automated mechanism for serializing structured data but with smaller, faster, and simpler manner makes it a very good candidate for data serialization use cases.</p> <p>JTS Topology Suite (JTS), which is a free and open source library containing geometries that correspond to the Simple Feature Access Standard.</p> <p>Main goal of the project is to define and implement of a serialization API based on JTS, which transparently serializes geometries based on the Simple Feature specification using Protocol Buffers. Extending support for other serialization frameworks such as Avro and support for raster data will also be addressed based on time constraints.</p>
<p>The Android Graphics Tools Team's GraphicsFuzz is a metamorphic testing framework for OpenGL and Vulkan graphics drivers. Among its tools are a shader generator, which mutates a shader program into variants that differ in machine code, but render a similar image to the original - and a shader reducer, which reduces shader code to focus on specific logic that a user is interested in. Used in tandem, these tools allow one to fuzz test shader compilers for flaws and easily reproduce them.</p> <p>The generator mutates a shader by performing "transformations" on the original code which complicate control/data flow. These transformations often make use of OpenGL's built-in functions and features to mutate expressions into equivalent forms.</p> <p>However, the generator and reducer are only aware of a subset of the OpenGL shader language, and do not support all of OpenGL's built-in math and transformation functions. This reduces the number of potential mutations and ultimately hampers GraphicsFuzz's capability of finding edge cases.</p> <p>This project aims to enhance GraphicsFuzz's support for OpenGL semantics and extend its capabilities with new transformations, then apply them to open-source drivers.</p>
Designing an open wallet based on the DIDMan specification requires consideration of several key components. These include authentication, DID management, cryptographic operations, interoperability, user interface, security, and backup and recovery. The OpenWallet must have a secure authentication mechanism and support the DIDMan specification to manage DIDs, their associated keys, and metadata. The wallet must also support cryptographic operations, have a user-friendly interface, ensure security, and allow for backup and recovery. By adhering to the DIDMan specification, the wallet can ensure interoperability with other compliant systems and promote the adoption of decentralized identity technologies. Expected Outcome - The expected outcomes of designing and spec-ing an OpenWallet based on the DIDMan specification include developing a deep understanding of decentralized identity systems, gaining practical experience in implementation and cryptography, and prioritizing security and user experience. - Additionally, students can expect to learn about interoperability, open-source contribution, technical documentation, and real-world applications. - By achieving these outcomes, students will be equipped with the skills and knowledge needed to make meaningful contributions to the growing field of decentralized identity technologies.
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>Currently a GRASS GIS user is forced to use Cartographic Composer or use another software (e.g. QGIS) to create hard copy map outputs with all features. The aim of this project is to develop complete basic cartography suite for the wxGUI Map Display so it could serve for most of the science publications. The goal is not to substitute QGIS Cart Comp or similar, it's just about completing all features so the cartography scripting abilities of GRASS GIS and its potential can be fully used.</p> <p>GRASS GIS contains some modules which would be good to implement into cartography suite for wxGUI Map Display. There are d.barscale, d.graph, d.histogram, d.legend and many other d.* commands to use. There are bugs in some of them and it needs to be fixed(options for map window size). Then there are some modules which need to be enhanced. Legend background is currently transparent -> add an options for opacity, border and corner settings. It's possible to set number of breaks/ticks for legend but values are not rounded -> add an option for manual brakes/ticks, add an option for automatic breaks/ticks (every ten, hundred)</p>
Envoy Gateway translates Kubernetes-native Gateway API resources into xDS configuration consumed by Envoy Proxy. It also manages the lifecycle of the Envoy Proxy fleet by generating Kubernetes resources such as Deployments and Services. Currently, upgrades to Envoy Gateway (the control plane) result in immediate, in-place updates to the associated Envoy Proxy fleet (the data plane). While this operation is designed to be zero-downtime, some users prefer a staged upgrade process where the control plane is updated first, followed by a progressive rollout of the data plane. This project aims to design and implement support for progressive data plane upgrades, allowing users to decouple the control and data plane upgrade processes. This would provide enhanced control and safer rollout strategies (e.g., canary or blue-green deployments). Expected Outcome: 1. Design a two-step upgrade workflow that separates control plane and data plane updates. 2. Implement configuration or CRD support to control rollout strategy of the Envoy Proxy fleet. 3. Add documentation and example manifests for users to adopt the new workflow.
<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>
The emergence of blockchain interoperability in the last few years has been playing a pivotal role in the development of blockchain technology. Hyperledger has been supporting multiple projects in this domain, leading to semantic and technical interoperability advancements. For example, Hyperledger has been investing resources in the adoption of different interoperability standards, such as the Secure Asset Transfer Protocol (SATP), being standardized at the Internet Engineering Task Force (IETF) However, security, privacy, and organizational interoperability are still the most prominent challenges in the space. This internship attempts to partially address these issues. This internship connects these three dots by offering the ability to Hyperledger Cacti to create robust consortia that adhere to privacy and security needs, required by organizations leveraging our open-source project. The present internship compresses the development and studying of the API Server, a core component of the Cacti Node. The mentee will develop API Server support for gRPC and the Connect protocols. Furthermore, an integration with SATP to create consortia will be performed. This can be achieved with some scripts for the end user to generate API Servers and SATP consortia configurations, served by a simple UI. This could become the new de-facto Cacti UI.
This Google Summer of Code (GSOC) project aims to improve the performance of the libc string manipulation function of the FreeBSD operating system on ARM-based systems (aarch64 architecture). The focus is on porting existing SIMD (Single Instruction Multiple Data) optimizations from the amd64 libc library to arm64, enabling FreeBSD to take full advantage of the NEON instruction set and laying the groundwork for future SVE support. This work builds upon previous SIMD enhancements done by Robert Clausecker <fuz@FreeBSD.org> for amd64. Deliverables include: Introduce a new ARCHLEVEL flag for the aarch64 architecture, allowing selection between base, NEON, and SVE instruction set extensions. This will involve creating an `aarch64_archlevel.h' header file to manage the different levels of architectural support. Update the `simd(7)' manual page to document the new SIMD-accelerated string functions for aarch64, including details on the ARCHLEVEL flag and its usage. And port the functions with already existing SIMD implementations for amd64 to aarch64. A full list of those functions are available at /src/lib/libc/amd64/string
<p>Currently, FreeCAD's IPython and Jupyter Notebook integration can only provide visualization by running the entire FreeCAD GUI alongside the notebook. Besides not being elegant it brings many problems with it, like not being able to save the visualizations inside the notebook for sharing or bringing visual complexity of the entire GUI into the view instead of just displaying the 3D model. It is therefore important to find a way to visualize FreeCAD's 3D scene in the IPython display system as supported by Jupyter Notebook.</p> <p>Tackling the open issue “IPython / Jupyter support” I aim to implement a IPython compatible visualization of FreeCAD’s 3D Open Inventor scene graph. To achieve this I intend to choose a suitable JavaScript library able to render a 3D scene graph and to implement a mapping between it and the Open Inventor scene graph. After this as a byproduct I want to implement a better WebGL export based on the scene graph instead of document objects as currently found in FreeCAD. For this I can reuse and integrate the scene graph mapping component. Lastly I want to document the results in the Wiki and create an example Jupyter notebook.</p>
This project extends the Fisheries Integrated Modeling System (FIMS) to support user-defined sex structure in population models. Currently, FIMS assumes a fixed 50/50 sex ratio, limiting its ability to represent sex-specific population dynamics used in stock assessment. To address this, the project introduces a partition-based framework that can enable sex-specific derived quantities (e.g. spawning biomass, landings) and population dynamics (e.g. mortality, selectivity) while minimizing computational overhead. Rather than implementing sex structure as a standalone feature, this approach supports a more general and extensible design for introducing partitions into the model. Three levels of model complexity will be developed and evaluated to balance flexibility and performance. The ultimate goal of this project is to implement an explicit two-sex model, which enables the capacity to model life-history dynamics differently between different sex groups. Benchmarking experiments will assess runtime and identify efficient configurations. Upon completion, this feature will expand the applicability of FIMS to a broader range of fisheries and stocks across the United States.
<p>Currently, the IKE and IPsec use UDP encapsulation whenever faced with NAT gateways which do not allow ESP or IKE packets. But some NAT rules even drop the UDP packets, only allowing TCP streams to go through. TCP encapsulation can reach through to hosts behind such NATs. An initiator must always try to send IKE_SA_INIT over UDP first, and if there are a certain number of transmission fails then only it should fall back to TCP. Another thing to do would be to schedule checks for UDP so we can go to establishing the tunnel using UDP if it becomes available and tear down the TCP IPsec tunnel. The above two steps are to be done as TCP encapsulation adds overheads and has performance trade offs compared to UDP, therefore we should always prefer using UDP unless required otherwise. Once the TCP support is added, we need to look into enabling ESPinTCP support in the kernel. The kernel must be able to identify TCP packets where the first 4 bytes are zero and we must tell the kernel to process ESPinTCP packets. Everything else will be done by following the draft RFC draft-ietf-ipsecme-tcp-encaps-09.</p>
The M-Competitions are a series of open competitions to evaluate forecasting methods for time-series data. The most recent competition in this series, M5, had their top submissions as Deep Learning models. Looking at these advances, the implementation of sktime’s deep learning module leaves a lot to be desired. As part of this project, the following will be the critical additions to the deep learning module: Add simple Deep Learning models for Forecasting like LSTMs, GRUs, MLP, etc. Include versatile and best performing models used in M5 for Forecasting (like N-Beats, use of LightGBM) Research existing best performing forecasting and classification models and implement them if required (e.g., methods based on Transfer Learning) Add soft functionality for ease of use (ensemble methods, send dataloader as input etc.) Provide improved documentation and tutorial notebooks for ease of understanding of users. After this project, users will be able to use deep learning models for forecasting and classification problems. They will be able to conveniently integrate sktime with their code, with an improved interface, varied inputs, better documentation, and tutorials for usage.
I would like to volunteer to develop SSH Client/Server support for NuttX. I believe this is a highly valuable feature, as it would enable remote access to NuttX-based hardware in the field for maintenance and operational purposes. With SSH support, we could remotely interact with devices, trigger I/Os, manage peripherals, and perform diagnostics in a way that is conceptually similar to what we already do on Linux-based systems. Also, this is a great opportunity for me to develop my skills. The implementation would be based on Dropbear, a lightweight and complete SSH stack with a small footprint, which makes it well-suited for embedded environments. There is already a reference port available that I plan to use as a development guide: https://github.com/david-cermak/dropbear The project would be structured in the following phases: Initial study phase to assess requirements and dependencies, including evaluation of cryptographic library integration and system constraints. Review of existing ports for other platforms (for example, ESP-IDF) to understand architectural decisions and integration patterns. Porting of the required SSH client and server functionalities to NuttX. Testing, validation, performance assessment, and resolution of identified issues. Mentors: Alan C. Assis, acassis@gmail.com
<p>HTTP Load balancer is a software application capable of distributing HTTP traffic to backend servers according to the specified scheduling policy.</p> <p>WSO2 Gateway is a high performance, lightweight, low-latency messaging gateway based on standard gateway pattern. Its Netty based non-blocking IO and Disruptor (ringbuffer) architecture makes it the fastest open-source gateway available. Benchmarks shows that the performance of gateway is very high when compared to other solutions and is close to the direct netty based backend (without any intermediate gateway).</p> <p>The following features will be implemented:</p> <ul> <li>Support for different Load Balancing Algorithms</li> <li>Full Compliance with HTTP specification</li> <li>Support for SSL </li> <li>Session Persistence</li> <li>Health Checking and Redirection</li> </ul> <p>This Load Balancer will a pluggable component. It will be able to achieve even load distribution through highly efficient, lightweight and low latency messaging. Thus, the performance will also be able to compete with existing load balancers.</p>
<p>High Level Trigger 1(HLT1) is the first and critical stage in software reconstruction of collisions at the LHCb experiment in the Large Hadron Collider at CERN. Allen aims to do full software reconstruction on GPUs.</p> <p>However the reconstruction must also be able to run on the LHCb baseline x86 architecture. Since Allen's algorithm are designed to be efficient on SIMD architectures, a natural translation to support x86 architectures is possible. The SPMD programming model bears resemblance to the SIMT programming model of CUDA, and is a natural target for code translation. Such an automated conversion would be beneficial not only for Allen, but for any CUDA projects seeking cross-architecture support.</p> <p>Exploiting vectorization on modern CPU is a hard task . Manual vectorization requires lot of developer time and maintenance can be hard. ISPC raises abstraction of SIMD via the SPMD programming model. Since SIMT programming model on GPUs closely resemble SIMD, the code conversion can be automated using an intermediate translation engine. The project aims to convert from CUDA to ISPC using translation engine based on LLVM.</p>
The Ensembl Plants and Metazoa platforms face a significant metadata gap where critical biological context, such as ploidy, strain, and sex, is often documented in peer-reviewed literature but missing from formal INSDC sequence archives. This lack of structured metadata, particularly ploidy, creates technical bottlenecks in downstream comparative genomics and requires labor-intensive manual curation. To address this, I propose developing a standalone, Python-based "Retrieve-Extract-Verify" module that leverages Large Language Models (LLMs) and Retrieval-Augmented Generation (RAG) to automate metadata extraction from scientific papers. This tool will utilize literature APIs like Europe PMC, employing section-aware parsing and confidence scoring to ensure high data integrity with minimal human intervention. My previous experience in building Transformer-based bioprocess optimization models and genome-level embeddings directly informs my approach to handling complex biological datasets. The final outcome will be a ready-to-deploy Nextflow module designed for seamless integration into Ensembl’s production pipeline and provide the global research community with richer, more reliable genomic metadata.
We usually need visualization, in fact, to enhance the interpretability of data or results, and facilitate the understanding of developers and users. In machine learning, 3D or 4D representation provides more depth information than the 2D representation, many of the tasks may be much better understood if we provide a 3D or 4D. But OpenVINO has no native real-time 3D visualization engine or library. This can be very troublesome for users who use display 3D images. So our goal is working natural 3D support for Jupyter Notebooks running OpenVINO (AI inference). There are a few solutions in Jupyter 3D graphic display, though: 1. Requires complex setup, build or is not friendly to the average user (without graphics programming experience) 2. Not integration with OpenVINO(Need process different data and different inference results available from OpenVINO, the user only needs a simple interface to set this up) The project idea aims at fill in the gaps mentioned above: 1. Provides a clean interface to set up the display of these graphics without the need for a graphical programming background(beginner-friendly) 2. 3D support for Jupyter Notebooks running OpenVINO(Be able to transform and process the output data of OpenVino)
This project aims to fine-tune Vision-Language Models (VLMs) for domain-specific tasks like object detection and hierarchical classification, focusing on real-world applications in fields such as medical diagnostics and biodiversity monitoring. Although VLMs like BLIP-2 and TinyCLIP show strong general-purpose performance, their effectiveness diminishes in specialized domains due to domain shifts, hierarchical label structures, and hardware constraints. To address this, we will implement efficient fine-tuning strategies—including LoRA, QLoRA, and adapter tuning—within the OpenVINO Training Extensions (OTX), enabling scalable training on consumer-grade GPUs. We’ll enhance these models with support for structured prediction and deploy them using OpenVINO’s quantization and optimization toolchain, ensuring fast, lightweight inference across devices. Beyond technical contributions, the project delivers practical tools and open-source pipelines that bring advanced multimodal AI to resource-limited environments. By supporting transparent, efficient deployment of VLMs in impactful domains, this work bridges cutting-edge research with high-value, real-world use cases.
<p>Dynamic volume mounting enables data persistence and sharing for pooled sandbox pods without relying on CSI plugins. This capability is essential for Agent workloads such as OpenClaw and Hermes, which need to save workspace data and share skills across sandboxes. Currently, OpenKruise Agents lacks support for open-source storage solutions like JuiceFS and Ceph, limiting adoption in on-premises environments. This project aims to integrate these storage backends by implementing CSI-plugin sidecars compatible with the Agent runtime and modifying the sandbox controller to support generic CSI volume mounting.</p><p><br></p><p>Expected Outcome:</p><p> - CSI-plugin sidecars for JuiceFS and Ceph that integrate seamlessly with the Agent runtime in OpenKruise Agents</p><p> - Sandbox controller enhancements to enable mounting of generic CSI volumes</p><p> - E2E tests covering core SandboxClaim flows involving JuiceFS and Ceph storage</p><p> - Comprehensive user-facing documentation published on the OpenKruise website and repository</p><p><br></p>
<p>digiKam 7.2 as of now, is fully compatible with Qt 5.15.2 on all major platforms. Qt6 has been released recently. Given that Qt5 and Qt6 are 8 years apart, the way of doing things has changed and complies with the C++17 standard. This project is aimed at preparing the digiKam project to be ported and released with Qt6 on Linux. Implementations that rely on deprecated, removed, improved APIs will be ported with a lot of regression testing.</p> <p>The AppImage is known to be broken as it doesn’t support internationalization, or proper ICU support. ICU works fine on other sources for digiKam like flatpak and native binaries. This issue will be fixed by porting the AppImage builder scripts to use Qt 5.15.2 with KDE Patches collection (Not for the moment) which was recently announced (<a href="https://dot.kde.org/2021/04/06/announcing-kdes-qt-5-patch-collection" target="_blank">https://dot.kde.org/2021/04/06/announcing-kdes-qt-5-patch-collection</a>). New scripts will be implemented to build the AppImage with Qt6 in future.</p>