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 UI Toolkit serves as a component library tailored for crafting web interfaces within the Jupyter ecosystem, encompassing platforms such as Jupyter Hub, Jupyter Widgets, and Jupyter Lab. With the introduction of this toolkit, the aim is to capitalise on its capabilities to enhance UI consistency and alleviate maintenance overhead. Here's a structured plan to achieve this: 1.Use toolkit search/input for all search/inputs: filebrowser, extension manager, debugger kernel source 2.Use toolkit button for all buttons: Dialog, extension manager, notification, running tabs 3.Use toolkit tree view for all tree view: table of content, debugger variables and running tabs 4.Use toolkit for the settings editor 5.Add icon component to the toolkit 6.Use toolkit icon for LabIcon 7.Add window split component to the toolkit 8.Add tree grid component to the toolkit 9.Add dock panel to the toolkit 10.Explore switching default renderer in lumino by the toolkit: a.Menu b.Tab panel c.Dock Panel I am committed to collaborating closely with my mentor, @Frédéric Collonval, to tackle these challenges efficiently and deliver tangible results within the stipulated timeframe of the Google Summer of Code program.
The Oppia development team is looking to enhance the quality of their software by implementing Acceptance Testing on the develop branch. The problem lies in ensuring that the application’s functionality aligns with user expectations and that bugs are detected and fixed before release. The solution is to automate tests for every PR, ensuring that key user journeys remain unbroken, thereby enhancing the reliability and user experience of the software. This project involves writing acceptance tests for all user stories and fixing any minor UI/UX issues that cause e2e test flakiness. The deliverables include a complete suite of acceptance tests that are easily auditable and maintainable, ensuring that critical user journeys can be tracked, and new tests can be added for new features in an organized manner.
Incremental compilation is a technique that helps increase compilation speed by recompiling only changed files instead of your whole program (also known as performing a clean build). By the time of this project, the Kotlin/Wasm compiler supports only clean builds. This project enhances the Kotlin/Wasm compiler to support incremental compilation, thereby improving the development experience by reducing build times and increasing productivity.
MariaDB provides `my_vsnprintf` (& `my_snprintf`) as a C `vsnprintf` alternative with platform-consistent results and custom extensions. However, these extension specifiers are incompatible with `printf` format checks in tools such as GCC. This project reworks these extensions to use suffixes to resemble ordinary C and removes the old syntaxes due to incompatibility. It also enables and utilizes said format checks to upgrade existing uses and catch up on mistakes sneaked in while these checks were inactive.
The aim is to develop an Android application optimized for LMIC healthcare settings, utilizing Google's Open Health Stack for offline functionality. The application will be designed to integrate seamlessly with the enhanced FHIR module of OpenMRS 3.0. This integration will enable efficient data management with capabilities for offline data collection, and two-way synchronization with OpenMRS 3.0 once connectivity is available, improving healthcare delivery in resource-limited settings.
It is common for kernel subsystems to conditionally include functionality, based on compile time and runtime configurations which are relatively infrequently subject to change. Typical examples include: toggling of DTrace probes, boot- time optimizations based on hardware capabilities and inclusion of additional security checks. This is often done by examining the state of a global flag and executing a block of code conditionally based on that state. When this is done in a ”hot” (i.e. frequently executed) code path, the overhead of the conditional execution can become significant. Moreover, in situations in which the state of the inspected flags changes rarely, most of the performed checks are redundant. The primary goal of this project is to design and implement a low overhead mechanism for conditional execution in contexts in which the branching condition does not change often. The mechanism will be based on runtime code patching of instructions. The second major goal is applying the developed mechanism to an existing block of kernel code.
This project aims to revamp the Neutralinojs ecosystem to enhance the experience for web developers creating native desktop apps. While the community has developed technology for web-to-native app conversion and offers essential native APIs, there's a significant opportunity to improve the developer experience and platform capabilities. The main objective is to create a package enabling developers to write backend code in their preferred language, supporting multi-language capabilities, and integrating CLI support for seamless backend management. The overhaul includes refining documentation with clear examples and instructions, enhancing templates, and integrating best practices for streamlined development. Additionally, improvements to the CLI interface will provide a user-friendly experience. By addressing these aspects, the project aims to attract more developers, empower existing users, and establish Neutralinojs as a premier platform for converting web apps to native desktop applications.
The Jitsi Meet Log Analyzer project aims to analyze log files created for different components of Jitsi Meet and develop tools that enable interactive search, filtering, scheduling and event processing. Utilizing Grafana Loki for log management and Open Telemetry for sending log data to Grafana Loki, the project aims to improve log analysing and system optimization. With Docker making deployment easier, the project searches, filters and makes logs easier to analyze for each Jitsi Meet component.
This project will set up Kerberos as part of the test suite using cwrap wrappers and write tests for the "gssapi-with-mic" user authentication method. It will also implement and test GSSAPI Key Exchange and “gssapi-keyex” user authentication method from RFC 4462 for both the libssh client and server.
Expanded and enhanced the nx-parallel project, a newly developed parallel backend for NetworkX utilizing joblib to parallelize graph algorithms. Key accomplishments include integrating NetworkX’s and joblib’s configuration systems into nx-parallel, switching the build tool from hatchling to setuptools, automating backend metadata updation through a pre-commit hook, enhancing and improving existing parallel graph algorithms by implementing chunking mechanisms, providing custom chunking capabilities for all algorithms, and centralizing testing frameworks. Also accomplished various enhancement and maintenance goals, such as improving algorithm performance, added new functionalities, error-free initialization for the `ParallelGraph` class and built a more comprehensive and improved README and a Contributor's guide. Beyond the proposed GSoC proposal, created a conda-forge feedstock for nx-parallel to enhance accessibility. My work also involved engaging with the NetworkX community, reviewing pull requests, and presenting talks and posters at various conferences/meet-ups. All the development workflow is well-documented in 8 GSoC Blogs written every 2 weeks during the project duration. Towards the end, I wrapped up my work by creating various issues discussing the future directions nx-parallel can go and features and functionalities nx-parallel can have. Refer the full final work product report and the initial proposal to know more and do check out the ideas in the "Experimental and more" section of the proposal that could be played around with, if you want to continue the work!
The project aims to provide a new code base, pgmoneta_ext, to enable pgmoneta to access files on the PostgreSQL server side, including the ability to read, analyze, and modify them. The project will be divided into four goals: 1. Develop a basic version of pgmoneta ext that accomplishes specific functions using add-on modules PostgreSQL extension. 2. Further enhance the pgmoneta ext function to retrieve metric information regarding backup and restore processes. 3. Implement additional permissions to access more files from the server instance. 4. Employ efficient strategies for compression and backup to support the delta backup infrastructure.
Empurrando Juntos (EJ) e Decidim são duas plataformas digitais distintas, mas que compartilham princípios e objetivos correlatos no que tange uma maior participação cidadã e o fortalecimento da democracia digital. Isso porque, ambas atuam como ferramentas que facilitam o engajamento dos cidadãos nos processos de tomada de decisão, tornando-os mais acessíveis para todos e, assim, estabelecendo espaços onde as pessoas possam acessar informações e participar de discussões pertinentes à sociedade em geral. A partir disso, essa proposta de projeto visa a criação de uma biblioteca Ruby reutilizável para integração da EJ com o Decidim, com o objetivo de facilitar o estudo das opiniões e do comportamento da sociedade através de dados estatísticos. Para isso, serão utilizadas técnicas de Aprendizado de Máquina (Machine Learning) para analisar as preferências dos usuários, identificando padrões de engajamento e desenvolvendo estratégias personalizadas para envolvê-los mais ativamente nos processos democráticos.
This is concerning adding the ability to add and sync bus routes and bus stops to the Public Transport Support - Subway Preprocessor and Validator project from the GTFS datasets and OSM database.
The project aims to integrate ConPLex for target selection and ESM for target validation into DeepChem, addressing the need for target selection and validation pipeline in DeepChem. By enhancing DeepChem with these capabilities, the project aims to streamline the drug discovery process, offering high accuracy in drug-target interaction predictions and insightful structural and functional analyses of potential targets. This integration is poised to significantly benefit the scientific machine learning and drug discovery communities by offering a more efficient, scalable, and interpretable method for identifying and validating drug targets, thereby accelerating the path from research to clinical application.
Develop new features to improve renders, testing and documentation in animint2. New Features: •Enable testing animint renderer using chromote •Add capability to layout ggplots in a html table •Port galley of animint example plots to GitHub pages gallery •Add capability to capture screenshot of aminint visualizations• New user configurable selection styles when using clickSelects
When I was little, one of my favorite 2D games was Super Mario Bros. I want to share this game with many people, but not only play, I also want them to be able to learn to make this game using the Catrobat platform with a fun experience. I want to help them make this game by making a Demo Project for the Super Mario Bros game. For me, working on this project means helping many children around the world to learn programming for free in a very interesting way. I believe all children should have easy access to education. Platforms like Catrobat are a bridge to make this happen and this is what motivated me to want to enter this project
Currently, Symbolics.jl has a Groebner basis implementation which is able to convert a myriad of symbolic expressions into multi-variate polynomials. This can be incredibly useful for solving functions for their roots, but to do so, a root finder for these generated polynomials must be implemented. Moreover, multiple users of Symbolics.jl have requested a symbolic nonlinear solver. As such, the project aims to complete the following: 1- Solve single variable polynomials (even high degree ones n ≥ 4) and multi-variable polynomials (over 2 dimensions or more) 2- Solve transcendental / other types of non-linear equations (highly requested: issues #961, #468, and #866) 3- Ensure that the implementation is well tested and well documented to make it more user-friendly and help out future contributors of the project.
Sktime provides a user-friendly interface for a range of forecasting algorithms and time-series functionalities. To enhance its capabilities further, we can integrate deep learning models from pytorch and huggingface. This integration will significantly extend Sktime’s functionality by incorporating advanced deep learning architectures, foundational models, and global forecasting capabilities.
The project aims to develop an AI-based Flutter application that will be connected to the Liquid Galaxy system and will allow users to ask the app any question about tourism in a simple chat-like manner or voice. The app will show the user itinerary, and recommended tourist places and will also show the history and significance of each place in both mobile as well as Liquid Galaxy system.
rustc-perf is composed of a data collector that collects rustc’s comiple & runtime benchmarks and web application that visualize the collected data. I'll be improving them by adding detailed runtime benchmark graphs, add query trace frontend inside of perf.rust-lang.org, migrate HTML templates to Vue.js.
A Device Tree (DT) is a data structure used to describe non-discoverable hardware to the OS or bootloader. It is written in a device tree source (.dts/.dtsi) file, which is compiled into the kernel image at build time. This structure provides a standardized way to describe a system’s hardware topology. Device Tree bindings are the rules and conventions used to describe devices within the Device Tree. These bindings define how to represent various hardware components. Device tree bindings were historically written in human readable (.txt) format and developers had to rely upon manually reading these files and writing device tree source files accordingly. Now, these files are being converted to DT schema (.yaml) format so that semantic validation can be done on device tree sources automatically.
Kerchunk is a python library which helps in streamline access to the climate modelling data stored in grib and other formats, by creating "references" for each file which maps to the acutal data stored in the cloud, without involving the overhead of downloading and local processing. The project encompasses building large aggregations by building an index table mapping from the references to every grib message in the idx files. This approach significantly reduces access time to the actual GRIB dataset, especially when dealing with large volumes of data stored in the cloud.
I will extend the existing OpenVINO GenAI text-to-image pipeline to support image-to-image functionality by incorporating ControlNet and utilizing the OpenPose detector. Additionally, I plan to create a new image-to-text pipeline using the CLIP model. Lastly, I will develop a cross-platform GUI using Qt to showcase these pipelines. I will deliver: 1. An image-to-image pipeline. 2. An image-to-text pipeline. 3. A cross-platform GUI. And if possible, more controlnet model could be implemented into image-to-image pipeline. Additionally, I'll explore the generation speed on CPU only, with integrated GPU (iGPU), and with the Intel Arc A770 GPU. I'll also investigate if I can build more similar projects using OpenVINO.
This proposal implements the DurationFormat API recently included in the ECMA-402 standard, an i18n aware way to format durations. This will be accomplished through ingesting data from the Common Locale Data Repository (CLDR) into ICU4X, then implementing a spec-compliant algorithm for formatting durations. This proposal delivers a well-documented, thoroughly-tested API that is accessible through the Rust ICU4X crate and languages such as C++ and Dart through FFI.