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.
As of march 2025 FreeCAD cannot have more than one active document. If a task is going on in a file, another file cannot be edited until that operation is resolved. The project's aim is to instantiate an editor per tab (document) and therefore allow parallel editing of multiple files. This would not only make the software more powerful for advanced users, but also friendlier for beginners.
A lot of work has been done to parallelize the Rust compiler frontend, with notable success in code generation and some post-HIR lowering stages. Other critical components, such as lexical parsing and macro expansion, are still implemented serially. Macro expansion is fundamental in Rust, enabling code generation at compile-time based on patterns and user-defined rules in the source code itself. However, due to dependencies between macros and the strict ordering of name resolution, its inherently sequential nature poses a significant challenge for parallelization. Currently, macro expansion and import resolution are tightly coupled and executed sequentially, making parallel execution difficult. This project aims to develop a parallel and order-independent algorithm for these two processes, improving compiler performance while maintaining correctness. Addressing the dependencies and execution order constraints could significantly reduce compilation time and enhance the compiler's overall compilation speed.
This project aims to extend the existing P4sim module integrated within the ns-3 network simulator by implementing control plane functionalities. The P4sim currently supports the simulation of P4-programmable data planes in ns-3, providing a powerful environment for research and development in programmable networking. This project proposes to bridge that gap by integrating a control plane to support P4 Runtime, like changing the openconfig-interfaces, the ethernet augments and other runtime configurable features. The enhancements will improve the realism and usability of the simulator for research and experimentation involving P4
This project is focused on significantly improving EvalAI’s usability by enhancing exsiting comprehensive test suite alongside a series of user experience enhancements. By increasing our test coverage, automating critical workflows, and refining the platform’s interface and documentation, this initiative aims to create a more robust, user-friendly, and resilient environment for both challenge hosts and participants. The enhanced test suite will ensure that all core functionalities, from challenge creation to submission processing are verified, reducing bugs and increasing system reliability. In parallel, targeted user experience improvements will simplify navigation, enhance error reporting, and streamline user interactions, leading to a more intuitive and supportive EvalAI ecosystem.
Liblouis Table Editor, a tool that helps users create and edit braille translation tables used by screen readers and braille devices. Editing these tables manually is difficult, especially when working with Unicode code points and special rules. I will add important missing features like forward and backward translation testing, fix existing bugs, improve the interface. I will also create easy-to-use installers for Linux and Windows.
This project aims to modernize the Speak Activity by integrating a large language model (LLM) & small language model (SLM) to enhance the chatbot and integrate a modern TTS model to improve the voice features, making it more educational and engaging for early learners. The Speak Activity, traditionally used for promoting reading skills through synthetic speech, will be upgraded to provide a more natural and interactive experience. The primary objective is to implement an LLM-based chatbot offering improved conversational abilities and a more human-like interaction style. For the voice feature a high-quality, natural-sounding Text-to-Speech (TTS) model that accurately handles pronunciation and phonetics will be used. By fine-tuning the LLM to manage invented spelling and grammatical inaccuracies, the chatbot will offer a supportive and child-friendly interaction, guiding learners in an encouraging manner. The project will utilize Python and a fine-tuned model hosted on the cloud and accessed via an API endpoint. This design ensures compatibility and seamless integration with the existing Speak Activity, without adding extra dependencies. To support offline functionality, a lightweight, fine-tuned fallback model will be packaged with the activity. This fallback ensures continued usability even without an internet connection, albeit with slightly less accurate responses compared to the cloud-hosted model. This enhancement will make the Speak Activity a more effective and child-friendly tool, promoting better language learning through engaging and conversational interactions.
App Inventor is becoming increasingly popular among users accessing the platform through mobile phones and handheld devices. In response to this trend, this project aims to implement an enhanced user interface tailored for smaller screens. By leveraging GWT's UiBinder framework, we will introduce flexible interface layouts that adapt to both device type and user preferences, ensuring a seamless and practical experience for mobile users. Deliverables will include optimized interface designs and usability improvements for small-screen devices, aligning with the growing accessibility of handheld technology globally.
I will develop the automated website generation mechanism for our open source by updating the facilitating tools and libraries to the latest versions, introducing new or refining existing tools to effectively automate the generation, decoupling the website generation logic from the main checkstyle core to avoid conflicts, and improving the existing state of user interaction with the website. In addition, I'm going to work on developing the corresponding checks and validations to ensure that all these tools for auto-generation are used and implemented properly.
Automate CPython JCC bridge binding generation for zero-copy NumPy array operations during orbital propagation sweeps.
This project extends the capabilities of the MedEye3D framework by developing an advanced visualization tool for supervoxel-based comparison across multiple medical imaging modalities (e.g., CT and MRI). The tool will enable users to interactively explore supervoxels on synchronized image views, with automatic highlighting of corresponding regions to aid in non-rigid registration and comparative analysis. Features include side-by-side image displays, interactive correction of supervoxel associations, and annotation of anatomical control points to support image alignment. Built using Julia, ModernGL.jl, and ITK/SimpleITK, this tool will enhance clinical workflows and research by improving registration accuracy and facilitating reliable visualization in complex imaging scenarios. The project contributes to digital twin applications in healthcare by enabling robust, user-guided multi-modality analysis.
Current driverless print servers can be complex and resource-demanding in large part since they only run on full-scale operating systems like Linux. This project aims to port the different elements of OpenPrinting's printing stack (CUPS, libcupsfilters, etc.) to the Zephyr OS for simple future print server development on embedded devices. This will consist of systematically adding Zephyr modules and commits to the OS itself for each part of the printing stack. Importantly, Zephyr replacements and ports must also be used instead of the current Linux dependencies. This leads to further investigation into the capabilities of the Zephyr OS to support technologies such as Ghostscript and print buffering. Lastly, the stack must be tested on hardware to verify functionality and view benchmarks such as power consumption.
Graphite uses the vello renderer to accelerate the image composition on the GPU. However, vello is only well suited for composing vector elements and plain raster images. It does not implement any operations for (post-)processing raster images, like adjusting hue, saturation, blurs, blending images, etc. Currently, these “raster ops” are evaluated on the CPU, significantly slowing editing to about 2-3 fps on a typical desktop system, making it unusable. I want to accelerate the processing of rasterization ops using the GPU to achieve acceptable levels of performance.
A much wanted and highly requested feature for neovim is the ability to edit remote files over ssh seamlessly. There is no native way of doing so and plugins do not feel as polished as expected. The aim of this project is to add such a feature to neovim.
This project aims to enhance Ferrostar by implementing a session recording and replay system for debugging and testing navigation flows. The system will provide an efficient and platform-independent recording system, allowing developers to capture interactions leading up to an error by manually enabling recording for testing. The recorded sessions can later be replayed to reproduce bugs, validate behavior across versions, and automate regression testing. This project will improve the developer experience and make Ferrostar more robust for production use.
The goal of the project presented in this proposal is to create a community library that will enable content creators in the Kolibri ecosystem to share their content with other users. This will allow users to create content channels, especially curated for specific learning environments or aligned to a certain curriculum, and make the content freely and easily discoverable and reusable by others. The project implements the project idea Easy sharing of community channels from the official Learning Equality idea list.
The project aims to integrate into the CGAL library an algorithm for medial axis approximation that I developed and published at SIGGRAPH Asia 2024. The algorithm computes an approximate medial axis of a 3D shape—represented either as a triangular mesh or a point cloud—using a variational sampling method that dynamically balances accuracy and robustness. It is designed to handle both clean and noisy input geometry, and supports dynamic updates, allowing users to interactively refine the result as needed.
The `loo` package is a widely used R package in the Stan ecosystem which exposes a clean API to cross-validate (CV) Bayesian models. As new CV methods and diagnostics are created and adopted by the field, the `loo` package must be updated to support them. Currently different predictive performance measures have different APIs and varying level of supported features. This project is focused on refactoring the API to unify the support for different predictive measures to make all useful features available for all predictive measures to make it easier for the modellers to use the most appropriate measures for their applications. Key technical components will include creating a flexible object which can report multiple metrics and scores. Additionally, we need to create functions to support model comparisons for all these scores and metrics. We will also allow for measures besides log score for LOO-CV to be used under the same, unified interface as existing options and create a consistent loo object for all measures. We will further unify the interface by allowing for non-log score measures for in-sample, test data, and K-fold-CV use cases. We will also be extending the model comparison functions to carry forward information on what measure is being compared, diagnostic data, and information on how to calculate the standard error (SE) of the differences of various measures.
Currently, Checkstyle relies on JDK 11, while the broader ecosystem has transitioned to JDK 21. This project aims to incrementally upgrade Checkstyle's minimum JDK version to JDK 17 and then to JDK 21. Additionally, dependencies such as Apache Doxia and other libraries will be updated to their latest versions to enhance maintainability, performance, and access to newer features.
This project proposal focuses on implementing a set of high-priority features in the zulip/zulip repository, specifically around enhancing channel-level settings and introducing support for creating and managing channel groups within an organization.
Large Language Model (LLM) serving frameworks like vLLM must deliver high throughput and low latency to justify the substantial cost of GPU and TPU deployments. This project targets systematic benchmarking, profiling, and optimization of vLLM, one of the most widely adopted open-source LLM serving systems. The goal is to push its performance limits under realistic workloads and contribute meaningful improvements back to the community.
This project aims to extract the Salt event processor from Uyuni's Tomcat web server and turn it into a standalone containerized service. Currently, Tomcat handles both web requests and Salt event processing. The problem is that processing Salt events can be resource-intensive, potentially affecting the performance of the web application also running in Tomcat. By decoupling these components, I'll create a containerized service that processes Salt events independently, improving overall system performance and reliability. The implementation will involve extracting the existing Salt event processing logic, packaging it as a standalone service, containerizing it, and extending Uyuni-tools to deploy and manage this new component with scalable considerations. The current event processing logic will be preserved while adding proper scaling, monitoring, and configuration capabilities. Deliverables include a fully functional Salt event processor containerized service, integration with Uyuni-tools for deployment management, documentation, and performance benchmarks showing improvements. This architectural improvement will allow Tomcat to focus solely on serving web requests while the event processor can handle Salt events in a more scalable manner.
The proposed project aims to automate the creation of nightly and release installers for InVesalius on macOS using GitHub Actions. By leveraging continuous integration workflows, this project will streamline the build, packaging, and distribution process, eliminating the need for manual compilation. The automation will utilize PyInstaller to generate macOS application bundles and installers while ensuring compatibility with system dependencies. This solution will enhance accessibility for macOS users, providing a reliable and up-to-date distribution method for InVesalius.
Apache SkyWalking BanyanDB currently supports only local file systems through the remote.FS interface, which limits its flexibility in cloud-native environments. This project aims to extend remote.FS by implementing support for major object storage services including AWS S3, Google Cloud Storage, and Azure Blob Storage. Each backend will fully comply with the remote.FS interface to ensure seamless integration. The implementation will include cloud-specific optimizations such as multipart uploads, resumable downloads, and SHA-256 checksum validation to ensure data integrity. Additionally, the system will handle rate limiting, transient errors, and support configurable retry strategies. The project will also include a unified error mapping layer and Prometheus-based monitoring metrics. Deliverables: • Production-ready remote.FS implementations for AWS S3, GCS, and Azure Blob Storage. • Unit and integration tests using tools like GoMock and LocalStack. • Logging and observability features with structured logs and Prometheus metrics. • Complete documentation and setup guides. • Community demo and contribution-ready pull requests. This enhancement will enable seamless and secure cloud deployments of BanyanDB, significantly reducing operational complexity while improving scalability and reliability.
The objective is to enhance the Beagle-Tester framework for BeagleBoard devices by adding mikroBUS support and updating it for mainline kernel testing. This project aims to develop an automated regression test suite for Linux kernel on BeagleBoard hardware, enabling continuous validation within the OpenBeagle CI server. The approach includes developing comprehensive test cases for interfaces such as PWM, ADC, UART, I2C, SPI, and GPIO, integrating automated power cycling capabilities for test farms, building a web interface for real-time monitoring of test results, and optimizing the framework for seamless Buildroot deployment. Key deliverables include an enhanced Beagle-Tester with mikroBUS support, an automated regression testing framework for kernel updates, a GitLab CI pipeline for weekly testing, a modular test farm design with power cycling capabilities, a web-based monitoring interface, and comprehensive documentation with tutorials.