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.
<p>Public lab wikis are used for collecting information, documentation and instructions on projects. And nature of wikis are that they can be edited by any logged in user. Just editing a wiki is not enough. There are times that other users would like to make comment on wikis. And there are occasions that others users would like to make suggestions on wikis. Sometimes they may need to comment or make suggestions for a part (for a paragraph) of the wiki. Currently wikis <strong>does not have any mechanism</strong> to make comments or suggestions. So implementing the ability of commenting and making suggestions on wiki pages would make them more interactive and discussion-oriented. And implementing these per paragraph basis will make wikis more alive.</p>
Reinstating automated threat suggestion per element was a feature in the threat dragon threat model designing system. Hence, upon migration to Vue.JS framework, not all features where migrated as that would take much effort to be completed. Yet, the project is continuously reinstating old features with new ones to make threat dragon an even better threat model designing system. This specific project is about suggesting threat type automatically for an element upon creation when drawing a threat model. My solution is about tracking our current existing threats for this element. and upon creating a new threat, the algorithm would check the existing threats and with the map it has for matching suggestions, it would pick the threat type suggestion for the next created threat.
<p>Interaction of a robot with the operator (human) is an important and daunting task. The aim of this project would be to create a clean, modern and modular Graphical User Interface (GUI) for the conversationalAgent component of RoboComp Viriato. The desktop application will be written using the Electron framework. The app would support one or more open source free to use Text to Speech engines like Mimic or MaryTTS. Combining such a TTS engine with a translation engine can enable the robot to converse in any of the given languages with the user. Leveraging various conversational skills provided by the chosen TTS engine like Mycroft’s Mimic (for example, intents, statements, prompts, confirmations, conversational context) can further help make the conversation feel more real and closer to an actual human conversation.</p>
When the KCL IDE encounters some errors in the KCL code, it can pop up `Quick Fix` prompts to help users quickly fix the errors. Expected Outcome: Added Quick Fix for some error prompts in KCL IDE.
The ShardingSphere parser engine can handle various SQL dialects such as MySQL, PostgreSQL, SQLServer, openGauss, and Oracle. Although the parser engine supports numerous PostgreSQL statements, some important PostgreSQL statements that start with ‘c’ require assistance in parsing and getting the SQLStatement (Java object). Therefore, this proposal aims to support those PostgreSQL statements for the parser engine. This will be achieved by: 1. Review the PostgreSQL SQL commands documentation and modify the target ANTLR g4 files (essential). 2. Implement the visit method (essential). 3. Add SQL cases and expected parse results (essential). 4. Run the associated tests to ensure no failures and exceptions (essential). Once the parser engine gets support for the target PostgreSQL statements, the users and developers of Apache ShardingSphere can be benefitted by working on these SQL statements.
C++ 17 and 20 released the par_unseq and unseq execution models which give guarantees to functions which specialize on them that data access functions can be interleaved even between iterations of one thread. This means that these functions are vectorization safe and can thus gain massive boosts in performance by compiler auto-vectorization. Compilers however are conservative and auto-vectorize loops only when they are sure that vectorized versions give the same result as their scalar counterparts and that vectorization will actually end up being profitable. GCC, Clang, MSVC, ICC all rely on different optimization passes in their backend and are all capable of auto-vectorizing certain loop patterns but not all. The goal of this project is to analyze compiler codegen response to different hints and implement a version of the par_unseq and unseq execution policies in HPX that makes use of these guarantees to provide compilers with as many hints as possible to encourage auto-vectorization.
<p>digiKam is a famous open source photo management software. With a huge effort, the developers of digiKam have implemented face detection and facial recognition features in a module called faces engine. This module implements different methods to scan faces and then label them based on the pre-tagged photos given by users.</p> <p>The most recent methods used in the faces engine use Convolution Neural Network (CNN) based algorithms for facial detection and recognition. Since Google Summer of Code 2019, with the excellent work of Thanh Trung Dinh[1], the SSD-MobileNet and YOLO algorithms for face detection, and OpenFace for facial recognition have been implemented using OpenCV DNN. His work has achieved a great precision in face detection and facial recognition. However, there still are some issues that affect the performance of the facial engine. Therefore, the objective of this project is to improve the performance of the digiKam faces engine.</p>
This project proposes to modernize DRuntime by converting legacy runtime hooks (functions that implement high-level language constructs like array operations and associative arrays) into compile-time templates. These hooks currently rely on dynamic type resolution via TypeInfo, introducing overhead that limits optimization opportunities. By leveraging D’s template metaprogramming, this work will enable compile-time specialization of these operations, improving runtime performance, potentially reducing binary sizes, and simplifying DRuntime maintenance. To achieve all this, my proposed solution comprises of three systematic steps for each hook: 1. Template implementation: Rewriting the hook as a template function in DRuntime, replacing the runtime TypeInfo queries with compile-time type parameters. 2. Compiler Integration: Modifying the DMD frontend to generate calls to the new templated hooks during the lowering phase. 3. Validation and Benchmarking: Verifying correctness through unit tests and quantifying performance improvements using benchmarks.
The Form Engine (FDE) is a specialized module for the OpenMRS healthcare platform. Its primary purpose is to enable a natural and efficient workflow for entering multiple pre-recorded forms at once. It is specifically designed for retrospective data entry tasks and is not intended for use in real-time, point-of-care clinical workflows. For comprehensive details and guidance, please refer to the official FDE Wiki [https://openmrs.atlassian.net/wiki/spaces/docs/pages/150962486/Key+O3+Repositories#Fast-Data-Entry] Documentation. Objectives of the GSoC project: This project will enhance the React Form Engine to natively support the requirements of the Fast Data Entry (FDE) feature. The improved engine will then be used by FDE to deliver faster and more efficient patient data entry. A key objective is to maintain full backwards compatibility with the existing Angular Form Engine, ensuring that current implementations continue to function smoothly while enabling a seamless transition to the React-based workflow.
<p>FreeType is an open-source library used to render fonts. FreeType is packed with a lot of complex font-related features, therefore, logging is an important aspect for this library. Freetype uses a home-brewed tracing and debugging facility which is well thought and designed but there is a limitation of this facility to write logs only on platforms that have inbuilt support for standard error. Therefore, this facility fails on platforms lacking standard error. Since FreeType is used on a variety of platforms, there is a strong need to enhance the current logging facility beyond a standard error in order to ease the development and debugging. The idea under this project is to enhance the existing design of writing logs to standard error to writing logs to the file system considering almost all platforms support input/output to files. There are multiple logging libraries that are freely available in the market and are stable, which will do the job of printing logs to a file. Hence, this project involves exploring the existing logging libraries, selecting one of them, integrating the same in FreeType and finally touching upon the testing part.</p>
The Vala compiler and the Vala API generator currently have no support for the latest GObject Introspection attributes. This proposal plans to add this support to both the Vala compiler and the Vala API generator. It also seeks to add GI-Docgen format support to Valadoc. I plan to make the Vala compiler support these attributes by making Vala.GIRWriter insert these attributes in the generation of GIR files. Similarly, Vala API generator can support these attributes if we make Vala.GirParser parse them from GIR files and add them to the Vala AST. Finally, the plan is to make libvaladoc parse comments in the GI-Docgen format. Upon the completion of this project, the Vala compiler and Vala API generator will be able to use these latest attributes in the generation and parsing of GIR files. It will also result in Valadoc being able to support the GI-Docgen documentation format so that it can be used with Vala GIR files. In addition, Valadoc documentation pages will have a modernized appearance and they will be able to render working GI-Docgen links.
<p>Interpreting genomic data largely relies on simulation software. One important family of software simulates population-level diversity over the course of evolution as a function of selection and demography. The ∂a∂i open-source package, developed by Ryan Gutenkunst (<a href="http://gutengroup.mcb.arizona.edu" target="_blank">http://gutengroup.mcb.arizona.edu</a>), is the leading software in the field, but is limited when handling large datasets.</p> <p>This project aims to overhaul the computational engine of the ∂a∂i software by implementing a recently developed approach for solving partial differential equations. The project will use ∂a∂i's interface and code-base, but introduce a new spectrum simulation engine. Using a moment-based approach will improve performance and reduce numerical uncertainty, offering the genetics community with a general-purpose simulation tool that can address larger and more complex datasets than previously possible.</p> <p>A prototype version of the computational engine is already running. The goal of this project will be to optimize the engine and embed it efficiently in the existing code-base.</p>
<p>Interactive visualization can provide intuitive insights for experiment setups and results in many domains, including High Energy Physics. Therefore, Virtual Point1 (VP1) was developed by ATLAS for 3D event display. Nevertheless, it seems a pity that it is based on an old graphics engine(OpenInventor) and resides in a big project(full ATLAS experiment software stack) with many dependencies.</p> <p>To get free of these limitations, GeoModelExplorer, a super-lighter version of VP1 has been developed, with a strong focus on the visualization of geometry data. Some of the important next steps are to replace the old 3D engine, improve existing functions and add more features. All of them are waiting for development.</p> <p>In this project, I will take these steps one by one, integrate the modern graphics engine Qt3D, improve the geometry rendering effects, extend the mesh I/O abilities, and add smooth animation for view inspections. There will be a large amount of design and engineering work but I will take extreme care. This project will eventually make contributions as part of the current software modernization effort in ATLAS.</p>
<p>In this project I will design and develop a semi-generic interface that enables Holmes Processing to manage the execution of advanced statistical and machine learning analysis operations. The system will have four core parts: core, analytic engine, rendering, and analytic services.</p> <p>The core will receive and schedule taskings as well as manage their execution and monitoring their state. It will also take care of the backend management necessary for the analytic engines.</p> <p>The analytic engine will provide a modular way to connect Machine Learning and statistical frameworks to the core and services to provide a generic way to connect to various technologies and vendors like Apache Spark and TensorFlow.</p> <p>Rendering will provide ways for humans to interact with the system by providing a API and website to display running jobs as well as their schedules and results.</p> <p>Analytic services provide the logic for the Machine Learning task. They should be able to daisy chain jobs together to leverage multiple engines at once, provide all necessary configuration for the job and the execution as well as an RESTful interface for communication.</p> <p>(Quoted and extended from the official Honeynet idea page)</p>
Versatile Video Codec (a.k.a VVC, H.266) is the successor to the popular High Efficiency Video Codec (a.k.a HEVC, H.265) video compression standard. In anticipation of industry adoption, the FFmpeg community has embarked on the ffvvc project, aiming to bring a VVC decoder into FFmpeg, the open source multimedia processing framework. FFmpeg is the backbone to many open source multimedia technologies, so a high-performance VVC decoder in FFmpeg will allow many other projects to process VVC-encoded video without the baggage of closed-source decoders. While modern compilers like Clang and GCC can employ tons of optimization techniques to speed up a compiled program, compilers are still not capible of generating high-performance code for DSP and video processing workloads. Modern compilers also struggle with the SIMD extensions introduced by CPU manufacturers, such as the AVX2 extensions released by Intel in 2014. These SIMD extensions massively improve performance in DSP and video processing workloads, and FFmpeg's HEVC decoder already employs AVX2 SIMD instructions to improve performance. Given that previous work into writing HEVC decoding filters in x86_64 assembly with SIMD instructed yielded tangible performance improvements, this proposal aims to implement the VVC deblocking filter in x86_64 assembly to improve the ffvvc decoder's performance on x86_64 processors.
<p>This proposal’s main goal is to add a concrete and fully functional form of implementation/procedure for processing of various messages and taking the required action. These messages are in turn extracted from the bounce messages which in turn are received to the sender when the email is not received by the receiver.</p>
I am Ryan, a college student finishing their last semester for a bachelors in computer science. My contribution to the multi-agent traffic optimization project would be to take the lessons I’ve learned from my previous bevy projects, and use them to update and improve rmf_site’s infrastructure over the course of several stages, and to use those improvements to add procedural generation for the tests sites that will then be used for multi-agent optimization testing. The stages for this would be as follows: 1. bevy 0.12 -> latest version of bevy + library updates.. 2. Compile time improvements 3. Debug tool improvements 4. test scenario automation through procedural generation. Update everything: The first thing to do would be to update rmf_site bevy and all other dependencies to their latest versions. I’ve done this for all my projects since bevy 0.11, and I can do it for rmf_site too. Improve Compile TImes: The next step would be improving compile times. When I tested this project on my local machine. Iterative compile times took around 50 seconds. With the appropriate restructuring of crates, slimmer crate imports, more granular feature flags, and the introduction of the mold linker, these recompile times could be cut down to around 2-7 seconds. Improve debug tools: After that, then comes adding more debug tools. We can add bevy_inspector_egui for bevy entity/component inspection, bevy_tracing for performance optimization via Tracy. Automate test scenarios: Lastly, would be adding procedural generation for test sites. First, would be adding initial tests with randomized prefab placement, then moving to procedural room layouts from tiles, then assigning different layout kinds to each of these, (storage room, office room, etc..), and then finally connecting these different layouts together into a single site.
This project proposes to enhance Clad, a Clang-based automatic differentiation (AD) tool, by leveraging its liveness analysis to automatically generate lock-free backward passes for highly parallel differentiable rendering pipelines. Specifically, the project targets the atomic bottleneck inherent in 3D Gaussian Splatting (3DGS) rasterization. Modern GPU-based differentiable renderers suffer from heavy use of atomic operations (e.g., atomicAdd) during the backward pass because many threads attempt to update the same pixel and gradient buffers simultaneously. This contention overwhelms L2 cache atomic units, stalling execution and causing the gradient computation to consume a significant portion of training time. My approach is twofold. First, I will redesign the rendering pipeline to avoid write conflicts by construction using deterministic sorting, tile-based memory ownership, and local accumulation before a single global write. Crucially, I plan to build this new architecture on top of my previous GSoC work that integrated the Thrust API into Clad. By utilizing Thrust's highly optimized parallel primitives (such as thrust::sort_by_key and thrust::reduce) for the sorting and tile-based operations, we can provide a clean, high-level C++ structure to the compiler. Second, I will utilize Clad to automatically generate the backward pass. By relying on Clad's liveness analysis, the compiler will prove exclusive memory ownership and automatically eliminate the need for atomicAdd calls. To isolate the compiler complexity from the graphics complexity, the project will use a differentiable geometry path tracer as the foundational stepping stone. Beyond differentiable rendering, this work establishes a foundation for compiler-driven automatic differentiation of parallel C++ programs, enabling efficient gradient computation in a wide range of high-performance computing applications.
Description: The new [Thanos PromQL Engine](https://github.com/thanos-community/promql-engine) has a sufficient separation between the syntax tree and the execution plan to allow us to query arbitrary data sources. In this project we would like to explore ways to query data stored in Apache Parquet files. Expected Outcome: The Thanos PromQL engine can query timeseries data from Apache Parquet files.
Most Joplin users are researchers or workers in different fields. It's usually the university or company dealing with them via email, whether it's assignments, essays, or reports, so I built a plugin to add the ability to fetch email messages (including attachments) and convert them to Joplin notes in various formats, either by monitoring any new or unread messages from a specific email address or a specific mailbox by using IMAP or by uploading downloaded email messages to the plugin without having to be logged in.
<p>The Slash Commands act as easy-to-use shortcuts for specific actions, whereas widgets are interactive messages which enables Zulip users to interact with external and internal services directly from the messages. My main aim is to create a feature different widgets and slash commands for Zulip, and also work on the ephemeral message system "zgrams". Apart from this, my project also includes building a bridge between IRC and Zulip and Improving the current import/export infrastructure.</p>
We seek to demonstrate the power of an open compiler stack and an open EDA stack in making contributions to software and hardware toolkits. By combining XLS and OpenROAD, we are able to test the ability of physical design to contribute to compiler design for Machine Learning acceleration. Along the way, we deliver several extensions to the XLS compiler, including several implementations of matrix multiplication and/or other ML-relevant operations. We also deliver a high level XLS-OpenROAD pipeline for future work, and for reproducibility.
<p>PySoy is a game creation engine where the aim is to give a remarkeable easy-to-use library to the developers compared to other game engines in the market. My project is to implement some shadow rendering algorithms so the creation gains a lot of value giving some sweet shadows. It'd be a step forward to a game engine used for more complex and good-looking games.</p> <p>The finality for this project is to add directional and no-directional light shadowing by including cubemaps instead of simple depthmaps.</p>
<p>IPv6 re-configuration through DHCP is a server triggered mechanism for the clients to update their IPv6 addresses and prefixes. The server behavior of sending and handling Reconfigure message is specified in RFC3315bis Internet draft. Kea-dhcpv6 server currently does not support Reconfigure messages and its associated remote key authentication protocol. The task of this project would be to extend Kea server software with the support of sending and handling of Reconfigure message in kea-dhcpv6 server as specified in RFC 3315-bis Internet Draft</p>