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 "Musical Ideation through Generative AI" project aims to integrate a Language Learning Model (LLM) with Sugar Labs' MusicBlocks platform, enabling users to compose and enhance musical compositions. It will start with implementing an efficient ABC parser for MusicBlocks, ensuring robust extraction of musical information from ABC notation. Next, the project will tune and benchmark the LLM to generate high-quality musical compositions in ABC format. Once tuned, the LLM will be deployed to a server environment, and API endpoints will be set up to enable interaction with MusicBlocks. Users will initiate compositions in MusicBlocks, which will be sent to the LLM for enhancement. The LLM will generate multiple compositions based on the user's input, which will be converted back to MusicBlocks format for further enhancement. Throughout the project, integration testing and flow testing will ensure seamless interaction between MusicBlocks and the LLM API. Comprehensive documentation will provide insights into the implementation process, results of benchmarking and testing, and recommendations for future improvements. This integration of AI-generated compositions into MusicBlocks aims to inspire creativity, deepen musical understanding, and enhance the learning experience for users
<p>A crucial step in developing a language pair is writing its bilingual dictionary, which maps a lemma X in language A to a lemma Y in language B if X and Y have the same meaning and lexical analysis.</p> <p>Apertium’s existing dataset has appreciable amounts of data, which can be visualized in a graph-like structure, previously done in the Apertium RDF project (Jorge Gracia et al., 2016). In essence, each pair is visualized as a ‘vertex’ on a graph, with an ‘edge’ between vertices that exist as a translation on Apertium. By exploring this graph, new translations can be inferred. In particular, bilingual dictionaries can be generated for any two languages that do not have an existing language pair but independently exist on Apertium.</p> <p>It is notable that polysemy diminishes the use of a simple transitive relation. Apertium’s existing “Crossdics” tool follows this model.</p> <p>My proposal will build upon the cycle density algorithm (M. Villegas et al., 2016) that defines confidence metrics in inferred edges based on cycle density. The underlying concept is that a cycle in the graph increases the confidence that vertices on the cycle are valid translation pairs.</p>
<p>Approximate Nearest Neighbor Search solutions become appealing in problems where dimensionality increases. Locality Sensitive Hashing is a popular algorithm for this task, but has important drawbacks: it requires a large amount of memory, and the number of parameters makes it less appealing to people unfamiliar with the inner workings of the algorithm.</p> <p>To reduce memory inefficiency, Multi-probe LSH (MPLSH) better utilises the memory used by LSH. MPLSH was shown to perform better with regards to both memory and execution time. Also, a model of LSH's performance has been developed, that allows users to easily explore the parameter space by using a small sample of the dataset.</p> <p>As part of my GSoC project, I am proposing the implementation of these two algorithms. The core LSH algorithm is already in mlpack, and I believe my proposed additions will</p> <ul> <li>make it easier for mlpack users to use LSH by alleviating the need to repeat the tedious tuning process every time a new dataset is introduced.</li> <li>make the current LSH implementation more efficient both time- and space-wise, by using a smarter algorithm and exploiting the benefits of parallelization.</li> </ul>
Planning a vacation can be quite a task. One of the challenges is finding some engaging details about destinations to explore. Often when we look into places to visit, we come across a range of options, which may result in making incorrect decisions and overspending. This situation can be disheartening for travelers like me. That's why there should be a method that enables us to explore travel spots, with just one prompt. Such a system would enhance the experience of planning a trip making it more delightful and fulfilling. Resolving this I came up with a tool (A Flutter App) that helps users plan travel adventures. By using one of the fastest Generative text AI models, Groq, it builds exciting tales of travelers exploring specific Points of Interest (POIs) selected by the user. The app creates a storyline around sub-POIs. Using the LG Rig the app presents the story in paragraphs each focusing on a sub-POI for a visually immersive experience. It also suggests tour recommendations on the screen to keep users engaged. And the Use cases of this tool is not just limited to travelers but also in education. Additionally, our app includes an accessibility feature to generate voice narration making sure all users can enjoy the experience.
<p>strace currently adds significant overhead to any application it traces. Even when users are interested in a handful of syscalls, strace will intercept all syscall made by the observed processes, involving several context switches per syscall.</p> <p>Since Linux 3.5, userspace applications can rely on seccomp-bpf to filter the syscalls they want to trace. In that case, the set of monitored syscalls is filtered in the kernel, using cBPF, before any context switch to userspace. strace could leverage seccomp-bpf to avoid tracing syscalls users don't want. The tracing landscape of Linux also drastically evolved in recent years. In particular, user applications can rely on eBPF programs to filter and aggregate data of interest in the kernel, with low overhead.</p> <p>During this Google Summer of Code, I will finish and merge the works started to 1) rely on seccomp-bpf to filter syscalls in kernel space and 2) allow strace to use alternative backends. That second work will come with a tracepoint/BPF proof of concept to ensure strace supports diverse backends, beyond the usual ptrace model.</p>
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.
<p>A typical workflow in interactive data analysis consists of :</p> <ul> <li>Loading data (e.g. a CSV on disk)</li> <li>Transforming the data</li> <li>Various data processing stages</li> <li>Storing the result in some form (e.g. in a database). </li> </ul> <p>The goal of this project is to provide a unified and idiomatic Haskell way of carrying out these tasks. Informally, you can think of “dplyr”/“tidyr” from the R ecosystem, but type safe. This project aims to provide a library with the following features:</p> <ol> <li>An efficient data structure for possibly larger-than-memory tabular data. The <code>Frames</code> library is notable prior work, and this project may build on top of it (namely, by extending its functionality for generating types from stored data).</li> <li>A set of functions to “tidy”/clean the data to bring it to a form fit for further analysis, e.g. splitting one column to multiple columns (“spread”) or vice versa (“gather”).</li> <li>A DSL for performing a representative set of relational operations e.g. filtering/aggregation.</li> </ol>
<p>AFL++’s mutation engine is optimized for compact data formats, such as images, multimedia, compressed data. However, the current AFL++ does not support grammar and therefore struggles with highly-structured inputs like PHP, JavaScript, or HTML . Although AFL++ allows users to define a dictionary, including language keywords, to help generate inputs, it still lacks more structured descriptions of the underlying syntax.</p> <p>To tackle the existing limitations of AFL++, the main goal of this project is to develop a pluggable grammar mutator that is integrated with AFL++’s mutation engine and can efficiently generate grammar-aware inputs. On one hand, like Nautilus, we want to combine grammar mutators with AFL++’s mutation engine. Also, we want to avoid the potential limitation of Nautilus: “over time Nautilus de-generates to structure-unaware greybox fuzzing”, as indicated by AFLSmart paper. On the other hand, we want to generate test cases efficiently as F1 fuzzer. Furthermore, to improve usability, we will develop a program generator that takes the grammar model as input and generates a mutator library, which is based on AFL++’s custom mutator APIs.</p>
As industrial manufacturing accelerates its digital transformation through advancements in robotics, adaptive production lines, and smart testing systems, cloud-edge collaboration has emerged as a critical enabler for deploying embodied intelligence in complex operational environments. Contemporary industry requirements for embodied intelligence now extend beyond basic task execution to encompass multimodal perception-decision integration, dynamic environment adaptation, and distributed device orchestration. Existing benchmarking frameworks exhibit limitations in evaluating scenario-specific embodied attributes inherent to industrial settings. This initiative leverages the KubeEdge-Ianvs collaborative AI framework, integrating domain-specific test datasets, simulation environments, and quantitative metrics to establish a certified industrial-grade evaluation infrastructure for embodied intelligence systems. Expected Outcome: 1. Develop an industrial-grade embodied intelligence dataset through systematic classification and reorganization of existing resources across four standardized task categories 2. Design standardized validation suites within KubeEdge-Ianvs 3. Deploy reference baseline algorithms using the developed validation suites to establish performance benchmarks within KubeEdge-Ianvs
<p>Detailed version: <a href="https://lab.civicrm.org/community-team/gsoc2018/issues/2" target="_blank">https://lab.civicrm.org/community-team/gsoc2018/issues/2</a></p> <p><strong>Synopsis</strong></p> <p>The project aims to build a new open-source fraud detection system for WMF. The 2 major steps involved are:</p> <pre><code>* experimenting with various anomaly detection techniques to figure out which one provides a required balance of precision (% of detected frauds which are actually fraudulent) and recall (% of all frauds detected); * providing the technique as an independent web service to WMF (like ORES) which can entertain requests to ascertain the authenticity of transactions. </code></pre> <p><strong>Stretch Goals</strong></p> <pre><code>* The web service uses the feedback from its decisions (new correct detection/wrong detection corrected by a human) to train the underlying model, improving its accuracy in the future. * Use something like LIME to provide a justification as to why our classifier chose to mark a transaction as fraud. * CiviCRM extension to interface directly with the web service. </code></pre>
The purpose of this project is to enhance the (Repository Service for TUF RSTUF) implementation by tackling critical areas that would significantly improve its functionality, scalability, and ease of adoption. RSTUF is designed to manage content distribution efficiently using the TUF (The Update Framework), but it currently has areas where improvements in delegation flexibility, performance, testing, and documentation are needed. This project will allow RSTUF to handle larger and more complex scenarios, while providing an improved experience for both developers and adopters. Goal - Enable succinct hash-bin delegations within custom delegations: Enhance the flexibility of RSTUF’s delegation model to allow for more fine-grained delegation control. - Improve performance on the online role bumping process: Optimize the process of updating large numbers of delegated roles to improve scalability, especially in environments where there are many roles to manage. - Enhance the developer experience by improving functional tests: Improve the effectiveness, reusability, and performance of the functional tests that ensure RSTUF’s features work across releases. - Improve documentation to facilitate easier adoption: Enhance the user-facing documentation to make it clearer, more comprehensive, and more accessible for new adopters, thus accelerating the onboarding process.
This project introduces an AI-powered agent that automates the transformation of API responses into structured UI schemas and functional UI components across various frontend frameworks. Using Multiple LLM-Based Agents, the system eliminates the need for manual UI creation by intelligently analysing API responses and generating corresponding UI structures. Additionally, it enables dynamic modification of UI components based on user prompts, allowing for customisation in design, layout, and behavior. By seamlessly integrating these capabilities into a unified workflow, the project streamlines frontend development, reducing manual effort and accelerating the UI generation process with a single-click solution. The project also aims to create a simple one-click API Request to Tool Generation pipeline that can enable external AI agents to interact with APIs without any manual coding Deliverables: • A Modular AI Agent Creation & calling mechanism for apidash's future AI-based tasks • One-Click solution to generate UI components from an API Response • One-Click solution to automatically generate API Tools to be used in various Agentic Frameworks like Langchain, Autogen and so on.
<h4>Author and organisation</h4> <ul> <li><strong>Name:</strong> Jorge Martínez Garrido</li> <li><strong>Organisation:</strong> poliastro - Open Astronomy</li> </ul> <h4>Application</h4> <h6><em>Improving poliastro Earth capabilities</em></h6> <h5>Summary</h5> <p>Nowadays poliastro includes different interplanetary capabilities, such us retrieving the user any body available in JPL database, Cowell's propagation under different perturbations or even plotting porkchops. However more features could be developed for Earth such us:</p> <ul> <li>Defining Earth-Moon and Solar System barycenter.</li> <li>New integrators such us Verner78 can improve computation times </li> <li>Atmospheric and gravitational models such us: Jacchia-Roberts, Russian GOST... </li> <li>Orbit determination, making use of external packages like the Aerospace Research Orbit determinator. </li> <li>Orbital and ground station keeping, rendezvous maneuvers, low-thrust guidance laws and others.</li> <li>Two-Line Element (TLE) retrieval from Celestrak.</li> </ul>
<p>Pallene is a statically typed, ahead-of-time-compiled sister language to Lua, with a focus on performance. Programmers can use Pallene instead of C modules and LuaJIT to improve and gain a predictable run-time performance. Pallene achieves this by translating a statically typed compilation unit into a C source file, which is implicitly compiled in the background.</p> <p>However, there are situations where removal of type annotations are useful.</p> <ul> <li>The main premise of Pallene is that it is compatible with Lua. This compatibility is defined as removing type annotations from a Pallene program results in transforming it into a Lua program. A Pallene to Lua translator will allow us to check whether this property is still valid. </li> <li>Provides greater portability, interoperability and integration with existing Lua codebase and tools.</li> <li>The Pallene developers could check if the unit tests are obeying the "gradual guarantee".</li> <li>In the benchmarks that do not use LuaJIT features, we could generate the Lua version of the code from the Pallene version.</li> </ul> <p>With the help of the Pallene to Lua translator, users can remove Pallene type annotations to generate plain Lua.</p>
GitHub issue: Opencv #27206, Opencv_contrib #3921 Fork with WIP: https://github.com/MykhailoTrushch/opencv_contrib As part of GSOC 2025 idea 11, implement algorithms for enhancement of technical quality of images. Based on the conversation in opencv-gsoc-202X mailing list, the main prioritized algorithms are: Smarter white balance algorithms Color corrections vignetting correction, chromatic aberration correction Exposure, contrast, temperature correction and enhancement in color images In my proposal, I outline some possible algorithms that would in the beginning be implemented for opencv_contrib and could be migrated to opencv, mostly in the photo module. In particular, in order of approximate importance: Auto white balance: implement FFCC Chromatic aberration correction: implement algorithm of Chang et al. Denoising: implement a CNN-based method as a module like dnn_superres Exposure correction: implement (Adaptive, Weighted) Gamma Correction Superresolution: check if any additional newer models for superresolution could be added If I am accepted as a contributor in GSOC, I expect to pursue 2-3 of these topics in-depth to fit in the timeframe of the medium-sized project (~175 hours). Also, the choice of algorithms is preliminary and might change after additional research and feedback.
This project aims to bring real-time, AI-powered live translation to the eventyay-video platform. Currently, the SUSI Translator prototype works well but relies on local computer microphones and standalone scripts. To make it ready for live online events, this project will upgrade it into a fast, web-native system that works entirely in the browser. The solution captures live audio directly from the speaker's browser, immediately filtering out silence to save server costs. This speech is then streamed at high speeds to a backend server. There, AI models (Whisper and an LLM) transcribe and translate the speech. To prevent robotic or broken grammar, the AI uses a "sliding window" to remember the last few spoken sentences, ensuring translations make sense in context. Finally, the translated text is sent back to the audience's screen as smooth, easy-to-read subtitles. Key Deliverables: - A browser-based audio capture and silence-filtering module. - A high-speed server connection (WebSockets) for instant data transfer. - A context-aware AI translation pipeline that prevents grammatical errors. - A stable, flicker-free subtitle interface built directly into the eventyay-video player.
OpenMRS lacks a printable visit summary, forcing patients to verbally relay medical history during referrals and care transitions. This project adds a Visit Summary PDF generator to the existing openmrs-module-patientdocuments module, reusing the proven Patient ID Sticker pipeline (DataSetEvaluator, XML Renderer, Apache FOP). The backend gathers visit-scoped clinical data (vitals, diagnoses, lab results with reference ranges, allergies, medications, visit notes) via batch queries, renders it as XML, and transforms it to PDF through XSLT. An extensible VisitSummarySectionProvider SPI allows any module (billing, appointments, pharmacy) to contribute sections without modifying the core module. Configuration uses deploy-time Initializer keys for section toggles, concept UUIDs, and page sizes (A4/A5/A6). The frontend adds a print button in the O3 visit-detail-overview-actions slot with iframe-based PDF preview and download fallback. Deliverables include the complete backend pipeline with all clinical sections, extensible SPI architecture, configurable XSLT stylesheet, REST endpoint with privilege enforcement, frontend print extension, comprehensive tests, and documentation.
This project implements a debuginfod-compatible server within Debusine to provide automated debug symbol resolution for Debian developers. Currently, debugging binaries built by Debusine requires manual installation of -dbgsym packages. This project aims to eliminate this manual labor by allowing tools like gdb to fetch symbols automatically via HTTP. Based on an analysis of the elf_classify logic in elfutils, I have designed and prototyped a pipeline that identifies and extracts .debug ELF files from -dbgsym.deb packages and parses their Build-IDs. The implementation integrates this extraction into the isolated sbuild worker task. These symbols are then indexed as debian:debug-symbol artifacts and served via a custom Django view that supports the buildid/<id>/debuginfo and executable endpoints, including HTTP Range requests for partial content. Key Deliverables: 1) An isolated extraction pipeline using pyelftools within the sbuild task. 2) A Django-based artifact storage and indexing model (debian:debug-symbol). 3) debuginfod-compliant HTTP endpoints (/debuginfo and /executable) with support for mandatory headers and 206 Partial Content. 4) Documentation and integration tests for gdb symbol resolution.
This project aims to develop and benchmark high-performance applications that leverage the modular SoC-Now platform, which integrates RISC-V cores, a vector coprocessor (Vaquita), and a post-quantum cryptography accelerator (Baby Kyber). The project will focus on building real-world applications such as image processing, machine learning inference, and secure communication, utilizing Vaquita for vectorized computing and Baby Kyber for post-quantum encryption. These applications will be designed, implemented, and tested on the SoC-Now platform, demonstrating the practical benefits of these hardware accelerators. The goal is to provide the open-source community with reusable application code and detailed performance benchmarks, showcasing the capabilities of SoC-Now in secure computing and efficient AI acceleration. The project will include the development of hybrid applications combining cryptography and vector processing, along with complete documentation and tutorials to make it easy for future developers to leverage the platform for their own projects. Deliverables will include working applications, performance benchmarks, and reusable code packaged for community use, with future work aiming to expand the scope with additional cryptographic primitives, AI models, and improved software stack integration.
<p>Krita digital painting app relies on quick painting response to give a natural experience. A painted line is composed of thousands of images placed one after the other. This image mask creation hast to be performed super fast as it is done thousands of times each second. If the process of applying the images on canvas is not fast enough the painting process gets compromised and the enjoyment of painting is reduced.</p> <p>Optimizing the mask creation can be done using the AVX instructions sets to apply transformation in vectors of data in one step. In this case the data is the image component coordinates composing the mask. Programming AVX can be done using Vc optimization library, which manages low level optimization adaptable to the user processor features. However the data must be prepared so it optimizes effectively. Optimization has already been done on the Default brush mask engine allowing it to be as much as 5 times faster than the current Gaussian mask engine.</p> <p>The project aims to improve painting performance by implementing AVX optimization code for Circular Gauss, Circular Soft, Rectangular Gaussian, Rectangular Soft Rectangular and Stamp mask.</p>
Introduction RISCV-ISAC: RISC-V ISAC is an ISA coverage extraction tool. Given a set of cover points and an execution trace of a test/application run on a model, ISAC can provide a report indicating in detail which of those cover points were covered by the test/application. ISAC also holds the capability to provide a detailed quality analysis on data propagation occurring within the test/application.RISCV-CTG is the RISC-V based Compatibility Test Generator. This tool is used to generate tests used in the official RISC-V Architectural Test Suite and the RISC-V architectural test framework RISCOF. All tests generated by the CTG are compliant with the official Test Format Spec. The CTG is similar to a constrained test generator capable of generating tests targeting a specific set of constraints. These constraints are supplied to the CTG using the Coverage Group Format (CGF) File. The CGF file contains various cover-points for different instructions. The CTG treats each cover-point as a constraint and employs a solver to identify potential solutions. CTG uses the constraint satisfaction problem (CSPs) solvers offered by the python-constraint package.
<p>Markov Logic Networks (MLNs) are a generalisation of first-order logic and probabilistic graphical models, thus forming a powerful mechanism of uncertain inference. PracMLN is an open-source toolkit that can be used to perform statistical relational learning (SRL) and probabilistic logic inference based on the Markov Logic representation. It was developed at the Institute for Artificial Intelligence at the University of Bremen.</p> <p>However, the software is written entirely in Python and can thus be slow at times. This project aims to rewrite some computationally intensive portions of PracMLN in Cython, and thus improve performance issues. Intelligent use of Cython's static typing functionality, which is unavailable in Python, will hopefully enable significant speedup, along with more extensive use of other similarly optimised libraries (such as NumPy).</p> <p>Additionally, this work will be documented (<a href="https://kaivalyar.github.io/gsoc18-pracmln/" target="_blank">https://kaivalyar.github.io/gsoc18-pracmln/</a>) in order to make further optimisation easier. Hopefully this will provide a clear, reproducible, live demonstration of the potential speedups that can be brought to PracMLN, along with a detailed guide for future contributors.</p>
Data Cleaning is one of the important and time-consuming steps in the Data Science and Data Analytics field. There are numerous methods, models, and algorithms for data cleaning processes that might be categorized under imputation, outlier detections, formatting, and visualizations among others. The process of evaluating these methods for a given dataset is challenging considering the volume of the dataset and the time/space complexities of the methods. Automation of the performance evaluation process can lead to a significant reduction in human efforts and time consumption with an unbiased comparison environment. The imputeTestbench package provides a benchmarking tool for automated performance evaluation and comparison of various imputation methods for time-series datasets. In its present form, the package is capable of handling time-series and temporal datasets. Imputation plays a crucial role in the fields of genetics and genomics. The aforementioned package can be very helpful if it can be modified to handle genetic or genomics datasets. It has huge potential in handling genetic/ genomics datasets and introducing parallel-processing and high-performance computing concepts. Considering these as a motivation, the goal of the project is to develop a new R package, modifying the imputeTestbench package for Genomics applications with better computational capabilities and will be named 'imputeTestbenchG'.
<p>This project will add the capacity for Perl 6 to produce and execute self-contained binaries on Windows, Linux, and MacOS. I will start with an executable binary for a basic Hello World program, and incrementally add support for linking to shared system and user libraries. Time permitting, I will work with my mentors to enable support and/or work arounds to enable linking to C and other languages.</p> <p>My approach will be similar to how the .NET Core creates self-contained and framework dependent deployment binaries. I have chosen this as a model as it has proven capable of running on Linux, Windows, and MacOS systems. While my work may focus initially on either Windows and the Portable Executable (PE) or Linux and Executable and Linkable Format (ELF), this approach will hopefully ensure a path forward that will eventually be capable of producing executable binaries on all popular modern operating systems.</p> <p>The basic method which the .NET Core uses to create executable binaries is by creating a manifest of information in the operating system dependent executable binary format which is linked to .NET’s runtime library, and handed to a .NET “main” function which executes the user program.</p>