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.
Until recently, explicit module builds were only supported for Clang modules. With the -fmodules-driver mode upstream patch being merged, the community can finally experience explicit builds for both Clang modules discovered through module map files and C++ named modules. However, one of the main advantages of modules is their ability to being cached. Currently, -fmodules-driver does not support this. Therefore, the proposal strives towards an effort to bring forth an efficient, correct and safe filesystem cache. The proposed filesystem cache will enforce strong concurrency control. Once this cache system is fully implemented, the community will be able to use and manage it with existing Clang flags along with -fmodules-driver mode.
The host to host ipsec transport mode works on Linux but does not work on any of the BSDs. The problem is a lack of IKE socket bypass , transport mode policies actually catch IKE traffic itself, which causes problems in establishing and tearing down connections. I will add a socket bypass for all three BSD also the API is different on each one. I will fix the SA mode labeling in the PFKEYv2 backend, add proper teardown and on demand testing to the existing test suite, and make sure everything works as expected on FreeBSD, NetBSD, and OpenBSD.
CRIU currently supports unprivileged checkpoint/restore in limited cases, but rootless containers remain unsupported because they introduce additional challenges around user namespaces, ptrace permissions, seccomp suspension, cgroup handling, and UID/GID mapping. This project aims to add a dedicated rootless-container checkpoint/restore path to CRIU rather than extending the existing --unprivileged mode. The implementation will introduce a user-namespace-aware helper architecture for dump, preserve cgroup state when delegation permits it, correctly capture and restore UID/GID mappings using newuidmap and newgidmap, and establish proper restore ordering for user and mount namespaces. Deliverables include the new rootless-container support path in CRIU, cgroup handling improvements, UID/GID mapping support, expanded rootless zdtm coverage, and documentation for the workflow and limitations.
sktime provides a unified Python API for time series forecasting, but its support for modern foundation models, large pretrained models capable of zero-shot forecasting, is still maturing. Several high-value models, such as Google TimesFM and IBM TinyTimeMixer, are not yet interfaced in sktime; existing foundation model adapters lack probabilistic output (predict_interval, predict_quantiles), and there is no shared wrapper to reduce the boilerplate cost of adding new models from the Hugging Face Hub. This project directly addresses those gaps. The primary deliverable is one production-ready foundation model adapter fully integrated into sktime's BaseForecaster API, with fit, predict, predict_interval, and predict_quantiles support, CI-passing tests, soft-dependency handling, and a usage tutorial.
I propose to work on the following project: porting the Chebfun package to GNU Octave. Chebfun is a numerical computation package for MATLAB that provides a framework for representing functions in a symbolic manner using ”Chebyshev technology”, a term coined by the package authors to describe the use of Chebyshev polynomials to represent functions up to machine precision. GNU Octave is supposed to be mostly compatible with MATLAB, so Chebfun should ideally work without change on the former, but there are some slight differences and unimplemented features in Octave that make this difficult. Primarily, the main issue is that Octave’s support for object-oriented programming (classdef) is not as feature complete and as stable as MATLAB’s, which is a major problem since Chebfun is written in classdef. The goal of this project is to port Chebfun to GNU Octave, and to make it work as a dropin replacement for the MATLAB version. Since fixing classdef is not a feasible/recommended goal for a GSoC project, I will instead focus primarily on making the necessary changes to the Chebfun codebase to make it work in Octave. Along the way, I will compile new information about the status of classdef in Octave, and I will share my findings with the Octave developers, and perhaps aid in some changes to the Octave codebase itself.
The proposal aims to develop the Jitsi Meet Speaker Queue project as part of the Google Summer of Code program. This project focuses on enhancing user experience by introducing a speaker queue feature that efficiently organizes participants ready to engage in discussions while accommodating the moderator’s preferred speaking order adjustment for participants, and maintaining a record of raised hands at the same time. To achieve these objectives, I will undertake several key steps, including the development of a user interface component, implementation of visual cues and indicators, establishment of a queue management system, refinement of the mobile application to encompass identical functionality, creation of comprehensive documentation, conducting rigorous testing, ensuring seamless integration and deployment, and designing an interactive guide. These steps will also serve as my deliverables for the project, which include a user interface component, visual cues and indicators on the UI, a queue management system implemented using React-Redux, a mobile app feature updating, and an interactive guide for the new feature. Overall, the overarching objectives encompass streamlining communication, promoting collaboration, and contributing to open-source sustainability.
Project: Enhancing Program Evaluation Research by Leveraging AI for Integrated Analysis of Mixed-Methods Data This project aims to leverage advanced data analytics and machine learning techniques to extract actionable insights from both quantitative and qualitative data collected from the survey. I plan to perform data integration, machine learning techniques and data visualizations to improve survey accuracy and efficiency and draw some valuable insights from results. Deliverables: Survey questions Script/code of programs used to determine the survey sample and perform the data weighting procedures on the data file Integrated data set including qualitative and quantitative data Script/code of programs used to preprocess data, select model and optimize for qualitative and quantitative data Visualization Dashboard presenting the analysis results, highlighting key insights for relationships and ease of use by stakeholders A final report including the analysis methodology, findings, predictive factors identified, and advices for stakeholders Open-source Repository including all code and models used in the analysis, along with documentation to enable replication and further research by the community
The proposal is about improving the QEMU emulator for the armv7 architecture on FreeBSD OS, it's goal is to get a simple C++ hello-world program to compile and run inside an armv7 jail hosted on an amd64 machine, using clang. To achieve this, about 32 syscalls need to be implemented for the qemu-bsd-user master branch, they are already implemented in the blitz branch, by the project mentor. The project is to add them to the master branch, perform testing and debugging of any errors, add them in a series of patches, each should pass the code review guidelines set up by QEMU developers. The solution starts by getting a stack trace of the syscalls that the compiler calls when using the blitz build of qemu-bsd-user, then compare them to the ones that succeed when using the master build of the qemu-bsd-user. Having done this, now we know which syscall are already added and those that are not. Now we proceed to add the missing ones, the project plan is included in the proposal. I will be delivering 32 patches to the qemu-devel mailing list, each one corresponding to a missing syscall.
Renode.io is an open-source software simulator designed specifically for System on Chips (SoC) and Internet of Things (IoT) devices. It allows developers to simulate the behavior of their hardware and software designs before deploying them onto real devices, saving time and resources. Currently, there has been no documentation or testing mechanism on how to use the renode.io simulator for RTEMS. Thus, this project is created to take a look at which BSPs RTEMS have that are compatible to be used in the renode.io simulator, submit a patch to the RTEMS User’s Guide on how to use it on how to run the them on renode.io simulator, and possibly integrate the renode.io simulator into RTEMS testing ecosystem as an opt-in simulator solution.
Pgexporter provides Prometheus metrics for PostgreSQL servers which include some core metrics, as well as custom metrics provided by users. The custom metrics are SQL queries that are run by the various servers, which subsequently may have a variety of PostgreSQL versions. If a query has parts of it not supported by a particular such server, then the whole query gets rejected. This proposal aims to solve this issue by enabling users to provide alternatives of the query of a metric along with the minimum PostgreSQL version on which each alternative query’s supported. Thus, whenever a particular server will need to be queried with a custom query, then based on the PostgreSQL version of the server, the corresponding query will be sent to the server, and the response will be formatted in the form of Prometheus metrics. This will greatly benefit both the users, as well as developers, to provide an out-of-the-box solution and would neither require the updation of codebases to cater to new PostgreSQL major version releases, nor would require the users to adapt to that change.
Thunar is a light-weight file manager under the XFCE project, written in C and GTK3. While functional and fast, it lacks some useful features present in other file managers, such as undo-redo, file counts for folders, and pictures specific maximized thumbnail view. This project aims to implement these features and add them to Thunar.
<p>An old-school survival game made using Pocket Code IDE and Tested on the Android Architecture. The basic gameplay is made up of different levels linked together in a forest, through which the player has to survive all the obstacles & enemies present to make progress. Each level has an unique design with special terrain elements with added power ups and weapons for the player to choose from. As the user progresses the game morphs itself into higher difficulty levels which houses extra traps and harder enemies to fight through.The goal is clear - Survive whatever The Forest has to throw at you.</p> <p>The game is supposed to be presented as an showcase of the capabilities of the Pocket Code Application. It will serve as a reference to all the wonderful features that can be implemented with ease on the Pocket Code.</p>
<p>The state of art of program repair for heap manipulating program has focus on specific properties of bugs, like null pointer dereference. We try to fix programs with pre-condition and post-condition written in separation logic. Given a program, we first run JSF to collect its post-state(p) by symbolic execution with the given pre-condition. Then we check if p entails the given post-condition(p'). If not, a bug is detected. Our approach to program repair has two main components: abduction and repair specification inference. First, we propose to infer the missing information to establish the post-condition through abduction using an existing solver. In particular, we infer a constraint f such that p * f is satisfied and p * f |-> p'. Secondly, based on abduction, we symbolically execute the input program with the abduction in a backward manner in order to construct repair specifications at every line of the input program. These repair specifications help to infer valid Hoare-style triples with fix candidates.</p>
<p>CarbonFootprint is a great initiative to make people aware of their unnoticed contributions to the degradation of this planet. This initiative needs to be expanded to reach out to a much more wider audience. Thus creating an API for this project can help achieve this task. Modern smart devices can make use of this interface to create new possibilities and information which I think can surely benefit the planet in some way.</p>
<p>The purpose of this GSoC project is to work on a variety of loose ends in, and general improvements to, the optimization package <a href="https://github.com/JuliaOpt/Optim.jl" target="_blank">Optim.jl</a>. Optim.jl is written entirely in the <a href="https://github.com/JuliaLang/julia" target="_blank">Julia Language</a>, and organized under the <a href="https://github.com/JuliaOpt/" target="_blank">JuliaOpt</a> organization. Improvements are in the form of a unified documentation effort, performance tests, improved algorithms, unit tests, and general bug fixing. At the end of GSoC Optim.jl should be a relatively well-polished, documented, and tested package for optimization in Julia.</p>
<p>ROS path planners such as MoveIt! and Descartes are good at finding feasible robot paths that avoid obstacles and optimize motion. In some applications, adjustments to nominal paths must be made based on sensor feedback or operator input. The issues were raised at ROSCON 2015 . The specific application driving this need is robotic assembly using end-effector force feedback, where parts such as computer board components need placement in holes or sockets with tight clearances, and the object locations may vary considerably with a need to locate them using vision systems. Achieving reactive and adaptive path planning may require extensions to several parts of ROS and ROS-Industrial, including the MoveIt! or Descartes path planners, the ROS control layer, or the Simple Message protocol to hardware robot controllers. Development can take place without actual force sensors or cameras, using simulated sources of the high-level outputs of these sensors in terms of small adjustments that affect the trajectories. The key software objective is to put in place a method to adjust trajectories after they have been nominally planned, rather than focusing on sensor processing.</p>
<p>Scilab being a software used worldwide, needs to focus on how its users (potential developers) interact with Scilab and how comfortable they are with using the features provided by Scilab. Scilab already incorporates the facility to make figures such as tables labels etc and allows insertion and manipulation of data. Unfortunately even though the facility is provided the features have been found buggy and not well documented making its usage very limited and which incapacitates the current users and fails to attract new users .There are some most wanted features like spreadsheets, progress bar etc which are not present and are highly wished for by the users of Scilab,and others.</p> <p>My aim is to improve/upgrade the already existing facility to such a level that the users become very comfortable using it and to further introduce much needed user interface elements in Scilab User Interface Control to make it most favoured software. My work starts with modifying and documenting Uitables and Uitrees and extends upto incorporating ProgressBar. These development would solve major issues with GUI,would attract more users to Scilab and would help in retaining already existing users</p>
This project will focus on applying hybrid end-to-end models that combine weighted convolutional-recurrent architectures (CNN-RNN) with large language models (LLMs) to recognize text from Spanish printed sources dating back to the seventeenth century. The ultimate goal is to create a user-friendly application that allows researchers to generate transcripts simply by uploading images in PDF or PNG format.
Neovim currently lacks built-in support for AI features. As a result, plugin developers need to reimplement the same core functionalities again and again. This leads to duplication and inconsistencies in the plugin ecosystem. This project aims to introduce AI-friendly primitives to streamline AI plugin development. It should add support for inline completion, buffer status indicators, a standardized progress API, and enhance prompt buffers with multiline support to be more friendly toward building AI-assisted workflows. These improvements should make it easy to integrate AI capabilities in Neovim while keeping Neovim performant, lightweight, and extensible as always.
This project enhances the OpenAFS Linux kernel module with multi-page folio support, addressing a key performance limitation in the current implementation. OpenAFS currently interacts with the Linux kernel's memory management system through single-page operations, despite recent kernel versions offering folio APIs capable of managing multiple contiguous pages as a single unit. I will implement comprehensive multi-page folio support in OpenAFS by modifying key components of the cache manager, particularly focusing on the VFS interface layer where the largest performance benefits can be realized. The implementation will optimize read and write paths to efficiently handle larger memory regions while maintaining backward compatibility with older kernel versions through autoconf detection and conditional compilation. By the end of the project, I will deliver: (1) A complete implementation of multi-page folio support that improves performance, especially for sequential read operations common in application deployment; (2) A comprehensive testing framework verifying functionality across multiple kernel versions; (3) Detailed performance benchmarks demonstrating throughput and resource utilization improvements; and (4) Thorough documentation of implementation details to facilitate future maintenance. All code will be submitted as incremental, well-structured patches adhering to OpenAFS coding standards.
Panoramax would make a priceless addition to the OpenStreetMap (and FOSS in general) community: the panoramic view feature improves map exploration and gives users access to 360-degree imagery that enhances the mapping process and gives important visual context. Live images can provide a lot of information that can be hard to determine, such as the weather or the terrain condition (like the snow level on ski slopes) and 360-degree are always breathtaking if taken in nature-filled and/or hard to reach places, like summit peaks or seashores. Milestones: 1. Understand how to implement the images, talk to the Panoramax team to get the most out of it and get familiar with the environment 2. Design how to add Panoramax in iD, understand how the image retrieval works and how to best implement it. 3. Get Coding! Write the new Panoramax page in iD 4. Write documentation, write tests, fix bugs and check if all is correctly implemented.
The project enhances Plone 6 by integrating Really Simple Syndication (RSS) support through two key components: exposing Plone content as RSS feeds and embedding external RSS feeds within Plone. A new rss_feed content type with a listing block, provided by the backend rss-provider add-on, and the express middleware in volto-rss-provider enable users to share Plone content as RSS feeds. The volto-rss-receiver add-on, which relies on the rss_mixer_data endpoint from the rss-receiver backend, supports efficient retrieval and display of external RSS feeds within Plone. This project simplifies content syndication and broadens the reach of Plone content, enhancing user engagement and accessibility.
KomaMRI.jl is a Julia package for Magnetic Resonance Imaging (MRI) simulation focused on speed and extensibility. Like other MRI simulators, it solves the Bloch equations, for which the solution can be parallelized due to the independent spin property of the system. Although KomaMRI currently has built-in support for GPU and CPU parallelization, GPU support is CUDA-based and could be extended to work with different GPU backends. In addition, writing GPU kernels tailored for the solution implementation could significantly improve performance compared with the current array-based approach. The goals for this project are to update the KomaMRI.jl package to support Metal, AMD, and OneAPI-based GPU backends, and create a new BlochKernel simulation method which is fully kernel-based and optimized. If time permits, the use of MPI.jl and Distributed.jl to run MRI simulations across multiple nodes and GPUs will also be explored.