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.
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.
Problem: In Apache RocketMQ 5.x POP orderly consumption, when a PushConsumer's ReceiveMessage response is lost due to network issues, the client generates a new attemptId for the next pull. However, the Broker blocks this new request because it still holds the original attemptId as active until its invisibleTime expires, causing consumption stalling. Solution: 1. Enhance client-side logic (ProcessQueueImpl) to add an application-level timer for each ReceiveMessage request 2. If timer expires without receiving response or definitive gRPC error: • Client assumes response was lost • Reuses original attemptId (instead of generating new one) for retry 3. Leverages Broker's existing capability to handle reentrant requests with same attemptId Deliverables: • Modified Java client code (rocketmq-clients-java) • Comprehensive tests (unit & integration) • Updated documentation if needed • Pull Requests to relevant RocketMQ repos Key benefit: Prevents consumption stalls by ensuring retries use same attemptId when responses are lost.
This project proposes a complete rewrite of BRL-CAD's existing OGV, which currently uses Meteor.js, an older framework no longer actively maintained. I suggest converting it to a more stable and maintainable framework. I plan to use Next.js, a modern React-based framework, for the frontend. SCSS/SASS will be used for styling, Nest.js will be used as the backend framework for better efficiency and type-safety, and Three.js will be used for modelling 3-D graphics on the web. Additionally, the frontend will be redesigned following industry-standard UI/UX best practices.. Also, it will be made sure to use libraries that have LTS support and are correctly maintained.
This project aims to build a static, user-friendly site that serves as an archive explorer for Freifunk’s historical social media twitter posts. These posts were archived in a SQLite3 database. Processing the database data will happen through an extraction tool that will be documented and set up for others in future projects. The website allows users to search for historical posts in a user-friendly fashion. An engaging configurable theme will be implemented in the site deliverable. Through this project, the archive will function as a positive reflection of the past and a welcoming introduction for new people discovering the history of the Freifunk community.
The project addresses a limitation in Clad, a Clang plugin for C++ automatic differentiation, which currently cannot fully support non-trivially copyable types, restricting its use in Object-Oriented Programming. I am going to enhance Clad's reverse mode differentiation by modifying its forward sweep functions to store intermediate values effectively and improving the To-Be-Recorded analysis to handle nested function calls and pointer operations. Deliverables include support for non-copyable types, enhanced TBR analysis, and optimized memory usage. These improvements will significantly extend Clad's applicability in modern C++ codebases using object-oriented design patterns.
Ruqola, a Qt-based Rocket.Chat client, currently lacks a robust implementation of end-to-end encryption (E2EE), making user communications vulnerable to interception. This project aims to design, implement, and integrate a complete E2EE workflow into Ruqola, ensuring secure messaging through strong cryptographic techniques. The project consists of two phases: Phase 1: Encryption Sandbox Develop a standalone Encryption Test GUI to prototype and validate E2EE workflows. Implement Master Key derivation (PBKDF2), RSA key pair generation, AES message encryption, and session key exchange. Create unit tests for core encryption processes. Phase 2: Ruqola Integration Integrate encryption into Ruqola’s communication system. Encrypt outgoing messages with session keys and decrypt incoming ones. Provide a user-friendly UI for encryption settings. By the end of the project, Ruqola will have a fully functional E2EE system, securing user messages with cryptographic best practices while maintaining an intuitive user experience.
This project aims to enhance the Jenkins Tekton Client Plugin by implementing full CRUD (Create, Read, Update, Delete) operations for Tekton resources, including Tasks, Pipelines, PipelineRuns, TaskRuns, Triggers, TriggerBindings, and TriggerTemplates. By adding Read and Update capabilities, the plugin will support complete lifecycle management directly from Jenkins, improving CI/CD workflows and reducing context switching. Deliverables include a fully functional plugin with CRUD support, improved error handling, integration with Jenkins credentials, user-friendly UI components, comprehensive testing, and detailed documentation. This enhancement will streamline cloud-native CI/CD management within Jenkins, making Tekton resources more accessible and manageable.
The proposed project aims to build a lightweight, scalable, and extensible alternative to the Snowstorm Terminology Server by leveraging Django and etcd—a fast, atomic, and consistent key-value store—as the backend database. Unlike Snowstorm, which is resource-intensive, limited to SNOMED CT, and does not support concept authoring, the new server will support full FHIR operations like $lookup, $validate-code, and $expand, along with custom endpoints for authoring, updating, and deleting concepts. Data will be loaded into optimized in-memory data structures (DAG and description dictionaries) on server startup, enabling fast traversal, search, and filtering. Multi-language support, real-time syncing from etcd, and an intuitive micro-frontend UI will allow users to manage codes seamlessly. The project also includes full integration into the existing Care ecosystem via a dedicated backend plugin and a React-based admin dashboard, ensuring drop-in replacement with no changes required in existing workflows. This solution will empower open-source healthcare platforms in resource-constrained regions to build, customize, and manage terminology services without relying on costly proprietary systems.
This project aims to create a robust, high-performance parser combined with an easy-to-use macro system for the Teal programming language. Leveraging a bicameral macro model, the project clearly distinguishes the parsing and macro expansion phases whilst still keeping the syntax streamlined. This enables flexible, powerful compile-time code transformations while maintaining clarity and efficiency in compiler design and performance.
Music Blocks is a visual programming environment that combines programming and music creation, but users often struggle to debug their projects due to unclear error messages and a lack of guided assistance. This challenge limits the platform’s educational potential. To address this, the project proposes an AI-powered debugger that will analyze user projects, detect errors, and provide real-time, context-aware solutions. By leveraging open-source LLMs like LLaMA 3 and Retrieval-Augmented Generation (RAG), the debugger will understand Music Blocks-specific issues and offer structured guidance, helping users learn while troubleshooting. The solution involves developing a JSON-to-text converter to interpret project structures, training an LLM on curated Music Blocks datasets, and implementing RAG to fetch relevant documentation and examples. A user-friendly debugger widget will be integrated into the Music Blocks interface, enabling seamless interaction with features like error detection, step-by-step explanations, and creative suggestions. The backend will use FastAPI for efficient API handling and AWS for scalable deployment, ensuring the system remains responsive and accessible to users worldwide. The debugger will empower users to independently troubleshoot projects, enhance learning, and make Music Blocks more accessible. By combining AI with guided problem-solving, it aligns with Sugar Labs’ mission to foster creativity and education through open-source tools.
Concerto, the core modeling language of the ACCORD PROJECT, is critical for smart legal contracts and domain modeling. This project aims to migrate from the current testing framework mocha to vitest which will enhance the performance, execution time and debugging capabilities. This process can be automated by the combination of vitest-codemod, regex transformations, ai assistance and some manual scripts required for handling complex test cases which cannot be automated. Here are the deliverables: 1. Migration from Mocha, Chai, Sinon to Vitest for all Concerto implementation. 2. A new Concerto conformance package which will be a standalone validation test package for all Concerto implementations.
This proposal tackles the challenge of efficiently running machine learning models on resource-constrained HiFi4 DSPs using Zephyr RTOS. The approach begins by deploying and validating open-source ML models (e.g., temperature prediction, micro-speech) on an emulated Xtensa platform before porting and optimizing TensorFlow Lite Micro for HiFi4 DSP using NXP’s AN13970 guide. Deliverables include an optimized ML framework for DSPs, a working sample application, comprehensive documentation, and upstream contributions to Zephyr.