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>Watercolor is one of the most complex tools for imitation. The painting, painted with watercolors, depends to a large extent on the motion of the pigment solution, on the paper worn. This process is rather difficult to model, because, depending on the environment, the system will continue to change for some time after the artist finished painting.</p>
<p>A support for Lua-scriptable syscall tampering and filtering will be added. It will be possible to inspect syscall arguments (including structures/unions of arbitrary complexity, given that their definitions are provided), passed both by value and by pointer (and write modified values back in case of the latter) using LuaJIT's FFI library or a compatible one (there are currently <a href="https://github.com/jmckaskill/luaffi" target="_blank">a standalone implementation of FFI library abandoned since 2013</a> and <a href="https://github.com/facebook/luaffifb" target="_blank">its fork by Facebook</a>).</p> <p>It will also be possible to perform fault/success/signal injection.</p> <p>A pull-style C API, as <a href="http://luajit.org/ext_ffi_semantics.html#callback_performance" target="_blank">LuaJIT's FFI documentation suggests</a> for minimizing context switching between C and Lua and thus maximizing performance, will be implemented, but a helper library written in Lua will wrap it to provide a convenient push-style one.</p> <p>Of course, everything added will be documented and tested well.</p>
<p>JuliaDiffEq is the most popular github organization for solving differential equations in Julia.Currently, it has an assorted collection of Ordinary Differential Equations (ODE), StochasticDifferential Equations (SDE) and Algebraic Differential Equations (DAE) solvers.</p> <p>But currently, there is no support for Partial Differential Equations (PDEs) which form an integral class of Differential equations found ubiquitously in natural sciences and engineering. PDEs are generally solved approximately by discretizing them to form ODEs which can then be solved separately.</p> <p>A toolbox to solve a large family of scientifically-interesting PDEs is thus sought. In light of this, I propose to create a toolbox of methods for discretizing PDEs in Julia.</p>
<p>Interpreting genomic data largely relies on simulation software. One important family of software simulates population-level diversity over the course of evolution as a function of selection and demography. The ∂a∂i open-source package, developed by Ryan Gutenkunst (<a href="http://gutengroup.mcb.arizona.edu" target="_blank">http://gutengroup.mcb.arizona.edu</a>), is the leading software in the field, but is limited when handling large datasets.</p> <p>This project aims to overhaul the computational engine of the ∂a∂i software by implementing a recently developed approach for solving partial differential equations. The project will use ∂a∂i's interface and code-base, but introduce a new spectrum simulation engine. Using a moment-based approach will improve performance and reduce numerical uncertainty, offering the genetics community with a general-purpose simulation tool that can address larger and more complex datasets than previously possible.</p> <p>A prototype version of the computational engine is already running. The goal of this project will be to optimize the engine and embed it efficiently in the existing code-base.</p>
<p>DigiKam is an advanced digital photo management application which enables user to view, manage, edit, organize, tag and share photographs under Linux systems. Currently, DigiKam use SQLite database support which is embedded database i.e. limited to local storage with one user. The goal of this proposal is to use MySQL database, which will provide the ease of more than one DigiKam accessing a remote and common database storage located on a remote server.</p>
<p>NetBSD currently doesn’t support Ext4fs. The aim of this project is to extend the code of Ext2fs to add Ext4fs read-only support. Additionally, the new functionality is supposed to be implemented in new files rather than making invasive changes in the files that are shared to some extent with UFS.</p>
<p>MdeiaWiki-CodeSniffer is a linting tool based on PHP_CodeSniffer. It helps MediaWiki to improve its code quality. This proposal aims to fix existing issues in the project, complete linting rules, add supports for linting method usages and standarize test files. <strong>Possible mentors: @Addshore, @EBernhardson, @Legoktm</strong>, <strong>Task Number: T89682</strong>, <strong>Proposal Task: T130574</strong></p>
The Clang Static Analyzer (CSA) can find a wide range of temporal memory errors such as use-after-free and dangling references. Some of its checkers, like cplusplus.InnerPointer, rely on hardcoded knowledge about the behavior of specific APIs. The Clang community has introduced lifetime annotations: [[clang::lifetimebound]] and [[clang::lifetime_capture_by(X)]] that let developers express lifetime relationships directly on their declarations and -Wlifetime-safety makes use of them. However, in partially annotated code, a single missing annotation is enough to prevent -Wlifetime-safety from finding the bug. The CSA can help in these situations by inlining the unannotated function. In my proposed project, I intend to implement a new standalone checker that reads lifetime annotations and tracks the resulting dependencies along different execution paths, using them as a fallback when the analyzer cannot inline a function body. The expected result is that the CSA detects lifetime bugs in both annotated and partially annotated code that it currently cannot catch, complementing the coverage provided by -Wlifetime-safety.
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.
The goal of this project is to provide an interface in Bespoke Synth for editing and running Faust programs in real time. This will provide Faust developers with access to a modular synthesizer that can be used as an IDE, and it will provide Bespoke Synth users with an accessible way to extend and modify the DSP of Bespoke Synth without having to recompile. This project will be implemented using C++, and will use the Faust embedded compiler.
Healthcare data is critical for decision-making, but the FHIR (Fast Healthcare Interoperability Resources) format, while powerful, can be challenging to navigate for many users. Our project addresses this accessibility gap by creating an intuitive tabular viewer that transforms complex nested FHIR resources into easy-to-understand tables. We're developing a Python-based solution that will automatically extract and organize FHIR data into user-friendly tables, making it immediately more accessible to researchers, clinicians, and community organizations. By simplifying how people interact with health data, we remove technical barriers that often prevent valuable insights from reaching those who need them most. Our deliverables include: A Python library that converts FHIR resources to tabular format An interactive web interface for exploring and filtering the data Documentation and examples to support adoption by various user groups Integration with existing FHIR servers for seamless data access This tool will democratize access to health information by making complex data structures approachable for everyone from data scientists to community health workers. When healthcare data becomes truly accessible, it empowers better decisions and ultimately improves health outcomes in our communities.
As multimodal agents become increasingly integrated into real-world applications, ensuring their safe and reliable tool-use behavior is paramount. We introduce ATIA, a novel evaluation suite designed to systematically assess the vulnerability of tool-calling agents to adversarial inputs. ATIA focuses on crafting malicious multimodal inputs—combinations of images, text, and other modalities—that covertly manipulate an agent's decision-making process regarding external tool invocations. By simulating a variety of attack vectors, including visual prompt injections, image–text conflicts, and spurious cross-modal cues, ATIA quantifies critical metrics such as tool call correctness, unsafe tool invocation rate, and adversarial success rate. This benchmark not only exposes potential weaknesses in current multimodal agent architectures but also provides actionable insights for developing robust, safe, and aligned systems. ATIA aims to serve as a reproducible and extensible framework, driving forward research in adversarial robustness and security for next-generation AI agents.
vertx-http-proxy is a programmable reverse proxy based on Vert.x. The current implementation uses interceptors to modify requests and responses during the HTTP calls. However, it’s inconvenient for developers to create interceptors for each rule they want to apply. This project will mainly focus on improving user experience by providing a builder API for transforming requests and responses from HTTP calls and enabling configure proxies by configuration files. Besides, it will also implement other useful features, such as cache storage integration and fine-grained management.
Pycxxwrap is a versatile Python decorator used to wrap C++ code into Python using Pybind11. It serves as a wrapper around Pybind11, a lightweight, header-only library that facilitates the exchange of C++ types between Python and C++. The primary goal of this project is to provide a Pythonic interface for C++ libraries, simplifying their usage and enabling the creation of Python libraries from existing C++ ones. Additionally, Pycxxwrap includes special support for the HPX library, a C++ Standard Library for Concurrency and Parallelism, using custom header files.
Snowflake is a pluggable transport that helps users bypass censorship and access the Tor network. It uses webRTC technology to create a peer-to-peer connection between the user's browser and a volunteer proxy server. The Tor project aims to create a new and improved website for Snowflake that provides a better user experience for both new and existing users. As the Snowflake has gained a lot of popularity recently, it has seen a significant increase in the number of visitors with various doubts and queries The existing website does not effectively address these concerns, so our goal is to create a user-friendly static & secured website that is easy to navigate and provides clear information about Snowflake and its proxies. At the End of this summer: 1. A new static website with a modern and intuitive layout for desktop and mobile devices integrated with other Tor Web products & follows tor's brand guidelines. 2. Improved Snowflake proxy guide for new and existing user 3. Ensuring the website is sustainable and easy to maintain by new contributors & developers over the long term.
Funded by GSoC this summer, I propose to add collision detection to CGAL in a way that naturally builds on and extends CGAL’s existing AABB-tree functionality. The project will focus on implementing trusted collision-detection methods, which are attested to by their use in projects like the Godot game engine as well as their continued academic propagation through works like Ericson’s “Real-Time Collision Detection” and courses like UT Austin’s “CS395T: Physical Simulation”. I envision the project having the following deliverables: - Modifications to CGAL’s existing AABB tree functionality where necessary, e.g. to handle moving bounding boxes and dynamic restructuring of the bounding volume hierarchy - Broad-phase collision detection routine that utilizes CGAL’s AABB tree to quickly rule out unnecessary collision queries and identify potential collision pairs - Narrow-phase collision detection routine that performs fast collision tests on the pairs of primitives identified in the broad phase - Tests to cover all changes and new functionality - Documentation of the above The full proposal can be found here: https://hackmd.io/@1V1uNkwcQMiMbp_OanOjUA/r1kG1v_-3
Self-adaptation is a key ability for future autonomous robots. Thanks to this capability, a robot is able to automatically adapt to changes during its operation. In the case of autonomous navigation, if the robot is endowed with this skill, it can automatically adjust a set of free parameters to improve its functioning given a cost function or metric. The effect of this adaptation is safer, more efficient, and, possibly, better socially aware navigation. The aim of this project would be to design and implement a sliding variable based adaptive controller that can self-adapt under varying circumstances. Through this the robot would be able to successfully navigate and self adapt under social constraints as well if required.
`cabal check` is a tool to check the correctness of a `.cabal` file and more generally to provide more useful output (warnings, especially related to uploading the package to Hackage). As now `cabal check` is an imprecise tool, outputting spurious warnings on well formed `.cabal` files. The mistakes become more and more annoying the more complex your package is (compilation flags, etc.). Picking up an AST, transforming it appropriately and *traversing* it is the only way to practically solve these problems. This proposal aim to do so.
The project aims to completely migrate the codebase of talawa-api from javascript to typescript. The project will introduce a strong type system in the codebase making every contributer adhere to that type system while contributing to the project. This will reduce the margin of errors that are introduced at runtime because of the dynamic nature of javascript. Other than that potential bugs will be addressed/fixed and other additional functionality will be introduced as needed by the project.
<p>PyQuotient are Python bindings to libQuotient, a Qt-based library to make client applications for Matrix and. The proposal includes also a basic Matrix client application in Python using PyQuotient.</p>
<p>I am applying to work on Ruma's automated checks issue <a href="https://github.com/ruma/ruma/issues/221" target="_blank">https://github.com/ruma/ruma/issues/221</a> to build a special-purpose tool to check code style rules and formatting specific to Ruma. I will use <code>rust-analyzer</code>'s <a href="https://github.com/rust-analyzer/rust-analyzer/tree/master/crates/syntax" target="_blank">syntax</a> crate to parse Rust files into a typed AST that is checked against rules. I plan to use this AST to be able to format code inside macros since this is a big part of Ruma. I have started a proof of concept tool <a href="https://github.com/DevinR528/ruma-check" target="_blank">ruma-check</a> that I will complete during GSoC.</p>
<p>This project is about creating a python library that implements the complete MIME Sniffing Standards. MIME stands for “Multipurpose Internet Mail Extensions.” This method is used to examine the type of content in a web request or response to determining the content’s format. Usually, we can determine a resource’s MIME type by looking at the Content-Type response header in an HTTP response but some developers set values for Content-Type headers that are not suitable for the response’s content. This is where MIME Sniffing comes into play to determine the actual MIME type by analyzing the response’s content.</p> <p>Misinterpreting MIME types can cause bugs while using Scrapy frameworks in projects. Therefore, we should implement the python library that can handle all the MIME sniffing standards. This library will follow the standards described in <a href="https://mimesniff.spec.whatwg.org/" target="_blank">https://mimesniff.spec.whatwg.org/</a>.</p>
<p>My goal for Google Summer of Code is to make OONI better at measuring TLS and QUIC blocking. OONI develops the open source software OONI Probe which provides tools for measuring internet censorship. QUIC is an emerging transport protocol that was initially designed by Google to solve problems with the existing TCP/TLS architecture. With increasing traffic volumes, it is significant to observe and measure QUIC blocking.<br> I want to identify and resolve existing inconsistencies with the QUIC code that I have contributed earlier this year.<br> Eventually, the QUIC code should get to a point where it can be used in production by the Desktop client. Therefore, the first deliverable of my GSoC project will be to integrate QUIC support into the OONI Web Connectivity experiment.<br> The second part of my project will be to implement the capability to parrot the TLS fingerprints of popular web browsers. TLS fingerprinting is a censorship method which identifies browsers based on the structure of the TLS ClientHello message. The ability of parroting TLS fingerprints will enable OONI Probe to measure and circumvent TLS fingerprinting.</p>
<p>JdeRobot’s Robotics-Academy is a framework for learning robotics and computer vision. It consists of a collection of robot programming exercises using Python language where the student has to code the behavior of a given (either simulated or real) robot to fit some task related to robotics or computer vision.</p> <p>The idea for this project is to introduce Evolutionary Robotics into Robotics-Academy developing exercises with mobile robots. Implementing Neural Networks and their related exercises are the main goals of the exercise.</p>