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 `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.
The proposed project aims to further investigate the potential of neural networks in accelerating the process of ray tracing for 3D rendering. Building upon the foundational work presented by Fujieda et al. at the 2023 High Performance Graphics conference and subsequent research conducted by Texas A\&M students at BRL-CAD, the primary objective is to explore the feasibility of utilizing neural networks for arbitrary shot line queries in ray tracing.
The UNO API allows developers to write code that works with LibreOffice, allowing programmatic control over the entire suite. This provides a robust platform for creating extensions, automations, and integrations with other software systems, whether the task at hand is manipulating documents, spreadsheets, presentations, databases, or drawing files. This proposal aims to upgrade the UNO API support for .NET languages to the latest versions, and bring the bindings to all platforms which support .NET 8. The end goal is to add a .NET 8 compatible binding, complete with a NuGet package for end users, tests and examples for demonstration and documentation to help new users familiarise themselves with the new bindings.
pocketpy is a lightweight Python interpreter that can be embedded in C++ applications. Though pocketpy has provided low-level APIs for creating Python bindings, it requires a lot of boilerplate wrapper code to bind complex C++ classes. The community has long expected a high-level solution for creating bindings. pybind11 is a header-only library that exposes C++ types in Python and vice versa, which has been widely used to create Python bindings of existing C++ code. Inspired by pybind11, this project aims to implement a compatible binding solution for pocketpy. By utilizing the template metaprogramming technique in C++17, we can extract metadata from C++ classes and functions and generate wrapper code automatically. By the end of this summer, header files compatible with pybind11 will be implemented for pocketpy. Existing pybind11 users can seamlessly migrate their bindings into pocketpy. New users can also benefit from this high-level binding solution. Additionally, we will test and verify the deliverables of the project in Cave Engine, a real-world product built on top of standard pybind11 header files.
While Sugar has lots of activities, you can never have enough math games and puzzles. This project will include developing 8 new math activities for Sugar inspired by the ideas provided here (https://www.cut-the-knot.org) by Alexander Bogomolny
HPX, as a framework designed for high performance computing, has various benchmarks for measuring the performance of its various components, which includes parallel algorithms, its runtime system, etc.. But these benchmarks (performance tests) lack a standardized format and a visualization tool that can help in analyzing performance trends over time, in different operating environments. Hence, the goal of this project is to standardize the benchmarks' output formats within HPX, and to also add integration with an external benchmarking framework, i.e., nanobench. Additionally, a visualization tool will also be developed, which will leverage the standardized formats to display the results of the benchmarks in an intuitive manner. Expected results: (1) A unified format for HPX benchmarking using chosen benchmarking framework. (2) Automating the installation of the chosen benchmarking framework in the HPX build system. (3) A visualization tool, developed using python and matplotlib, to display the results. (4) Integration of this plotting tool with CI/CD pipelines, to track and display performance reductions or improvements
The process of transcranial magnetic stimulation neuronavigation involves the generation of motor evoked potentials (MEP), which are detected and measured using electromyography. These MEP signals can be effectively represented through a color map projected onto the brain surface. This innovative approach enables real-time visualization of brain motor mapping, offering a dynamic and comprehensive understanding of neural activity during the procedure. Requirements: Computer with Windows, Linux or Mac OS installed. A source code editor, Python language and InVesalius libraries dependencies. Deliverables: Develop pipeline to receive motor mapping data using websocket Projection of motor mapping data, based on the neuronavigation position, in the brain surface GUI to define the color map preferences and customize the number of stimuli Coordinate communication between the websocket data receiver, projection module, and GUI.
My proposal aims to improve the user experience and developer experience for AsyncAPI-Preview extension. The main problem being solved is the difficulty in identifying and resolving common and custom linting errors in AsyncAPI documents. By leveraging the VSCode API for providing quick/autofixes for linting errors, my proposal plans to add an "Auto Fix" feature for most common and standard Spectral linting errors in AsyncAPI documents. The proposed deliverables for this project include: -Integration of AsyncAPI-Preview and Spectral for VSCode extensions -Implementation of Code Actions for standard Spectral linting errors in AsyncAPI documents -Support for computing json-path to source code and vice versa -Investigation on loading autofix rules from external files to support custom (non-standard) Spectral linting rules Overall, this project aims to streamline the AsyncAPI-Preview process and improve the quality of AsyncAPI documents by providing developers with a more user-friendly and efficient way to identify and fix common and custom linting errors.
This project aims to shrink BlackParrot multicore to have a minimal variant called TinyParrot multicore. The main goal of this project is to get very low resource ASIC tapeouts. The deliverables of this project are: **Provide Minimal ISA support: This will be done by parameterizing the FPU logic (all the FP pipes, register file, and bypass paths). **Shrink the size of caches: The cache size will be reduced to 1kb of data. **Logic saving optimizations: The optimizations are planned to be done through Yosys. Yosys supports optimization passes and runs them while synthesis.
Add new selection features, improve the speed of the existing compiler and render, and fix bugs for animint2 package. New Features: •User-configurable selection styles. Implementing by modifying the D3 aesthetic. •Make data visualizations with large data sets compiled faster, by introducing dependency on data.table. •Move the computations of updating axes/legends after changing the currently displayed data subset to the renderer. Optimization: •Upgrade to d3.js version 4
<p>Many genes both within and across species share a common origin. Homologoy inference is concerned with disentangling the precise nature of this shared origin and is essential for performing comparative genomics studies between species where previously unseen genes are annotated by comparing protein sequences to those of a known species. Inferring such relationships is can be computationally expensive. Deep learning offers a way to infer homolgy relations based on a limited set of data. This project will build upon previous work to develop a faster pre-processing pipeline and boost predictive performance for more distantly related species.</p>
<p>I want to improve the kernel environment model by developing models for operations with strings. Also I want to reduce rate of wrong verdicts to LDV and CPAchecker projects</p>
<p>The Project has 3 sub-parts which are described as:</p> <ol> <li><strong>Initial Firmware Retrieval: </strong> People who want to update their device, often do not know what firmware file to download. So far the best option is the Wiki, but it is often loaded with too much information. The file download organizes all images files by architecture, but that is what most user usually do not know beforehand. </li> <li><strong>Firmware Upgrades: </strong> Create a router web interface package for LuCI to check and apply new images.</li> <li><strong>Creating meta-data for each target: </strong> To get the data for both projects, the OpenWrt build system needs to modified to create json files with the necessary metadata.</li> </ol>
<p>My proposal aims to create a new component that allows to store the representation of the robot’s world over time, as well as query it. For this, it is necessary to store the graph structure used to represent the knowledge of the world that the robot possesses. In RoboComp, when robots need to perform complex tasks, its behaviour is based on missions. The mission begin from an initial state and through different transitions reaches a final state, that is, the robot completes the mission. The states are represented by a graph. My proposal is to use a JSON structure to store this graph. This allows its storage as a collection of documents in MongoDB. Consequently, each document could represent a state of the robot. Also, this slot is intended to study the viability of Neo4J for this purpose, as far as I am concerned, the best option would be to use the polyglot persistence, that consists in to use the database best suited for the type of data, in our case MongoDB, and in to use the database best suited for the type of queries, in our case Neo4j. Specifically I think that Neo4j Doc Manager could be our best choice.</p>
<p>Infrastructure management is an important part of every project as we are always faced with the need to make regular releases of new features and applying consistent testing methods while doing so. The aim of this project is to expand the code coverage of the unit and integration tests for the Submitty project. This project will not just focus on introducing new tests to increase code coverage but will also focus on the best ways to implement, automate and execute the suites. In short, this GSoC project is about the Continuous Integration (CI) of Submitty projects mainly in PHP and Python where the majority of the tests are written and would be concerned mainly with writing tests (testing), automating the building and deployment of Submitty.</p>
<p>Realistic hair or fur is essential when creating a plausible virtual world. In feature animation, this is often used to define the signature look of characters; examples include Pixar’s <em>Brave</em> (Iben et al. 2013), and Walt Disney Animation Studios’ <em>Tangled</em> (Sadeghi et al. 2010; also Ward et al. 2010) and <em>Zootopia</em> (Chiang et al. 2016).</p> <p>Currently, Cycles has a working hair shader (<a href="https://docs.blender.org/manual/en/dev/render/cycles/nodes/types/shaders/hair.html" target="_blank">wiki page</a>, <a href="https://git.blender.org/gitweb/gitweb.cgi/cycles.git/blob/HEAD:/src/kernel/closure/bsdf_hair.h" target="_blank">sources</a>), based on Marschner et al. (2003)’s model. Its several assumptions and simplifications make it inaccurate for light colored hair (d’Eon et al. 2011) as well as for most types of fur (Yan et al. 2015). Furthermore, d’Eon et al. (2011) and Khungurn and Marschner (2017) demonstrated it to not be energy conserving.</p> <p>This project intends to upgrade Cycles’ hair shader to the aforementioned <em>Zootopia</em> shader by Chiang et al. (2016), by porting Pharr (2017)’s implementation. Lukas Stockner has made available <a href="https://github.com/lukasstockner/blender/tree/hairshader" target="_blank">a WIP patch </a>, which may also serve as a basis for this work.</p>
<p>Currently, many components of Git are still in the form of Shell or Perl scripts. This choice makes sense especially when considering how faster new features can be implemented in Shell and Perl scripts, rather than writing them in C. However, in production, where Git runs daily on millions of computers with distinct configurations (i.e. different operating systems) some problems appear (i.e. POSIX-to-Windows path conversion issues).</p> <p>The idea of this project is to take “git-stash.sh” and reimplement it in C. Apart from fixing compatibility issues and increasing the performance by going one step closer to native code, I believe this is an excellent excuse to fix long-standing bugs or implement new minor features.</p>
<p>Vowpal Wabbit is an online machine learning system that is known for its speed and scalability and is widely used in research and industry. The goal of this project is to provide the reworked functionality of Vowpal Wabbit to R.</p>
<p>The goal of this project is to provide a new option in the clang static analyzer to validate (or refute) reported bugs, by using an SMT solver. The implementation consists of an extra step, after the bug is found by the built-in solver (RangedConstraintManager) but before reporting it to the user; the path and the constraints that trigger the bug will be encoded in SMT and checked for satisfiability using the SMT solver Z3. The expected result of the project is to reduce the number of false bugs reported by the analyzer and evaluate the overhead introduced by Z3 during validation.</p>
<p>The aim of this project is to enhance the DBpedia Knowledge Base by enabling the model to learn from the corpus and generate embeddings for different entities, such as classes, instances and properties. While we do this, it is imperative that these embeddings are able to accommodate the semantic relatedness between entities. This means that we are not limiting ourselves with just the similarity between words, instead we take a step further ahead to also define the relatedness between the vectors and thus the relation between the entities and the text. Therefore, to incorporate this measure of the semantic distance, we define a measure of descriptiveness of the class that these entities belong to. Entities belonging to a class that has a very high level of description must have very low semantic distance in our model. Eventually, we extend the usability by predicting embeddings for out-of-vocabulary entities as well, and also extract relations between those entities using approaches that have been previously used for link prediction tasks in machine learning.</p>
<p>The primary aim of the project is to create an android application for field workers that would receive push notifications sent by their supervisors. The android application would communicate with ODK Service for authentication. Another important aim of the project is to build a standalone Java application through which supervisors can push notifications to their field workers.</p>