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.
Performance evaluation is one of the concerns about using ModSecurity and Core Rule Sets. More specifically, people take different approaches to examine the performance, such as stability tests (e.g., the peak of I/O, speed of re-connection) and capacity tests (e.g., use of disks). However, individuals often miss measuring before/after using the Firewall. Secondly, although there are many open-source utilities (e.g., Apache JMeter, httperf), no specific tool is designed to evaluate performance affected by a firewall. To address the issue, I suggest creating a CLI tool to benchmark the performance with CRS. A list of deliverables includes: 1) Define a framework for testing performance for a generic WAF. 2) Research existing utilities for performance testing on WAF. 3) Create a CLI tool to achieve the framework and define different types of testing performed by the tool. 4) Implement different types of performance testing. 5) Integrate the CLI tool with pipelines (e.g., GitHub pipeline). 6) Based on the existing Docker images, perform different evaluations with different configurations/versions. 7) Documentation.
Currently, Talawa misses a web-app for regular users. Creating a User Portal for regular users, makes Talawa accessible to an even larger audience. User can send direct messages, group messages, view/create/delete posts, create/view/delete events through the User Portal. The user portal will be created using Material UI.
For years, the government has struggled to provide helpful information for residents in need. Sometimes the resources are not readily accessible, or the channel of communication is simply missing. Many people have questions about government policies but don’t know where to ask or never bother to read through official documents; instead, they end up getting incomplete or misleading information from the web. These issues call for a system that handles queries on a large scale with high efficiency and consistency - this is where large language models (LLM) come into the picture. With the help of exciting tools like LlamaIndex, we are now able to extend the knowledge base of LLMs like ChatGPT to more specific domains and tailor the model’s responses to be more relevant to the residents’ needs. This project will extend ChatGPT’s knowledge base with specific government data (such as pdfs of housing policies) and provide a frontend interface for user to interact with a ChatGPT-style chatbot. In addition to the ability to chat and ask questions, users will also be given the power to evaluate responses of the chatbot by giving a thumb up/thumb down to the response.
Sustainability is a key goal for KDE over the next two years. As part of this goal, KDE aims to measure the energy consumption of its software and eco-certify applications with the Blue Angel ecolabel. Currently, we measure the energy consumption of our software using a lab based in Berlin following the process documented in the KDE Eco Handbook (Handbook: Applying The Blue Angel Criteria To Free Software). The lab setup requires (i) a test PC (System Under Test) to run user-emulation scripts, (ii) a power meter to measure the energy consumption of the test PC, and (iii) another PC (Data Aggregator & Evaluator) to collect and analyze the output data. In the current setup, developers must rely on individuals in Berlin to test software for them on-site in the lab. This proposal aims to provide remote access to the lab in two steps: first, automating the energy measurement process, including providing a summary of the results; and second, setting up backend CI/CD integration for measuring energy consumption. By automating the process and providing remote access, we make it possible for developers to measure the energy consumption of their software from any location in the world. The increased access to the lab will enable data-driven decision-making for efficiency improvements in code and software eco-certification with agencies like the Blue Angel. The proposed project has three main goals: i) Measurement Automation: Implement a solution where a developer provides as input three scripts (baseline, idle mode, and standard usage scenario) with a config file and automatically obtains a summary of results from OSCAR (Open source Software Consumption Analysis in R). ii) Remote Access 1: Implement a CI/CD pipeline as a backend solution for performing the energy consumption measurements in the remote energy measurement lab.
This project aims to automate the testing of stylus touch pens with Chromebook using a human motion robot (HMR). Currently, stylus pens or any other touchpad-related test cases take much longer time and are more expensive when going through lab testing. Developing and conducting these tests via a human motion robot will save half the cost and accelerate the testing time from 13 hours to 15 minutes. The objectives of this project include evaluating and assessing the pass/fail of stylus test cases, developing automation scripts for onboarding the HMR, and implementing the HMR’s testing lifecycle to run and evaluate test results. A three-step evaluation procedure has been proposed, and the onboarding automation scripts and the HMR lifecycle have been implemented. Evaluation results show successful evaluations with directions on future work aiming to improve and scale up the proposed approach.
The assumption system underlying SymPy is very important to the library's function. However, it has several flaws, including sluggish performance and being overly interconnected with the core of SymPy. As a result of its flaws, a new assumption system, the "new assumptions," was proposed about a decade ago. Since then, the community has made slow but incremental progress in transitioning to and improving this new system. One of the main reasons for this change is that the old assumption system doesn't allow for relation assumptions to be expressed. While the new assumption system does support relational assumptions, the current implementation is very limited. My project aims to address this limitation by enabling the new assumption system to make inferences based on equalities and inequalities, such as "if x > 0, then x must be positive."
BookBrainz currently has no administration system, or any good way of giving users special privileges. This project involves devising and implementing a basic admin system allowing for a flexible privilege hierarchy. This project will also include creating relationship and identifier editors which allow privileged users to edit and add relationships and identifiers.
This project extends the work from the previous year, which included basic algorithms for multi-camera calibration, by adding testing cases with wider coverage, refining the algorithm to be comparable to the Kalibr tool, and improving the API to make it more accessible to users. Additionally, it plans to create improved documentation to guide users with little background knowledge in camera calibration. The overall goal is to provide a reliable and robust implementation of camera calibration algorithms in a multi-camera setup.
Currently sctk uses pyahocorasick intbitset for license detection & lxml for creating cyclonedx-xml output formats. All three of them are currently implemented as a extension of python using c or cython these libraries are important for the performance of scancode, but they need to be compiled and installed in a specific way, which may not be possible on all computers. This can make scancode less portable or difficult to use for some users who do not have the necessary tools or libraries installed on their machines. Therefore to address this issue the proposal is to create fallback dependencies, that are written in python and can be used by scancode when the required c libraries are not available making it easier to install and use on a wider range of machines
This project would start by extending a library called libipuz. This library loads and saves puzzles from the free ipuz file format. They would add support to load Acrostics from disk. Testing support will also be added. Once the files are loading, they would add support to the game itself through widget work. They'd have to write two custom widgets. First, they would write an answer widget that contains a sub-grid and links styles with the main grid. Then they'd modify the clue row widget for acrostics to support the different types of clues. As a final step, a separate widget will be written to add a custom layout for acrostics. Given those acrostics behave differently than crosswords, we want to lay them out differently. This can be done either by extending the existing custom widget, or them writing their own.
The IEEE 802.11 specification for Wireless Local Area Networking (WLAN) has been widely deployed worldwide due to its low cost and convenience in providing internet access. As such, the performance of WiFi networks is far from optimal, especially when multiple participants share the same channel in an uncoordinated manner. Hence, resource allocation in wireless transmission plays a vital role in optimizing the throughput of a link. The aim of this project is to implement a joint power and rate controller in user space using the Rateman Python package. As a rate control algorithm in user space has already been developed at SupraCoNeX, namely "py_minstrel_ht", this variant of Minstrel-HT can be extended with power tuning capability to better manage interference and increase spatial reuse. In general, the proposed joint controller will consist of a power tuning module that tweaks the power level of the set of best rates, selected by the Minstrel-HT, to an optimal value. Furthermore, the joint controller could also be extended to support modes such as fixed power and low power.
This project proposal focuses on improving two DrTest plugins: Coverage and Executable Comment. In particular, to enhance how these plugins show the results to facilitate developer analysis by: (a) adding a statement coverage visualization view; (b) showing detailed coverage statistics; and (c) adding more grouping options in the result panel. Complementary, we propose to add a new plugin that allows developers to perform mutation testing analysis.
This project aims to create a high-quality custom dataset using PaLM API and create a high-quality text summarization model by fine-tuning a pre-trained model with the custom dataset. The custom dataset will be a CSV file with 10K rows and 4 columns: id, prompt, document, and summary. The document should vary in different writing styles such as news articles, blog posts, legal papers and so on, and the length of a summary will be between 1/3 and 1/4 of the length of the original document. This will make the custom dataset to be far superior to most publicly available datasets like CNN-Daily-Mail or XSUM, which typically generate 1-2 sentence summaries. Then I will create a few text summarization models with different pre-trained models, improving each fine-tuned model’s accuracy by implementing strategy driven from bias/variance and error analysis. After creating a few fine-tuned models, I will pick the best performing one based on the evaluation metric. Based on this, I will work on creating a tutorial covering the whole process, such as creating a custom dataset using PaLM API, fine-tuning pre-trained models using Keras API, and selecting the best performing one based on a evaluation metric. As a result, by creating this comprehensive tutorial, the project will encourage other developers to explore/use Keras API and PaLM API in their projects.
My idea is to develop a language pair for Highland Puebla Nahuatl (`azz`) and Western Sierra Puebla Nahuatl (`nhi`). Both are endangered variants of Nahuatl (`nah`, but different branches), and are in contact where they are spoken. `azz` is a higher-resource language with publications and government materials, whereas `nhi` is substantially more endangered with only some short stories available. There are monolingual repositories for both, so I'm interested in developing the bilingual dictionaries and transfer rules. This would really nice to have, especially since speakers of both languages often live in the same or neighboring areas, and there is interest in being able to translate materials from one variant to another.
The objective of this proposal is to implement a new data fetch layer for frontend in Plone CMS. I intend to implement a library “@plone/client” that will work as a client for “plone.restapi”, using Tanstack Query. This client will enable Plone to move away from the “AsyncConnect” data fetch layer that is based on Redux. Then Redux can be used as the application-level data store only. TanStack Query brings many benefits with it, like caching support, de-duplication of queries, cancellation, refetch, easy-to-use hooks, SSR support, and more. A modern API client should use these features fully. The primary goal of this client is to be robust, yet flexible enough to support all use cases, and be easily extensible.
GNOME Settings (aka gnome-control-center) is GNOME's main interface for configuration of various aspects of your desktop. GNOME Network Displays is a standalone application for casting your display's content onto another remote display in the network. The goal of this project would be to reuse the work in gnome-network-displays to be able to manage remote displays in the GNOME Settings Display panel. Allowing users to select the remote display from the list where they already can find local displays/monitors. This work will involve iterating with the GNOME design team and discussing the UX of the functionality.
My goal is to enhance the Keploy Typescript SDK's versatility and accommodate a wider range of developers and use cases. I aim to make it more flexible, allowing for easier future integration of additional technologies/databases by creating reusable code blocks. Major deliverables: 1. Add support for Httpclients in TypeScript 2. Add support for popular SQL databases using Sequelize 3. Add support for MongoDB database 4. Add support for cloud storage services 5. Add support for Redis and Elasticsearch 6. Sample Project: Include a sample application that will contain all the above integrations in the Sample-Typescript repo for seamless testing of each implementation.
Scarpe is a project designed to resurrect the shoes library using modern technology. This project aims to leverage an HTML/CSS/JS/RUBY stack to develop GUI apps, which can be deployed across various platforms.. The primary objective of Scarpe is to bring it closer to shoes by ensuring that all known examples run seamlessly. The project also aims to create comprehensive documentation and build an official Scarpe website to provide easy access to project resources. Furthermore, there are plans to make Glimmer lib UI an efficient secondary display service. Scarpe represents a significant opportunity to modernize the shoes library and bring it to a wider audience
PyDataStructs is a high-performance python package for data structures and algorithms providing C++ backend via Python C-API as well as a parallel computation that provides lightning performance. a) Single package for all data structures and algorithms. b) Consistent APIs and Clean Interface. c) Supported on all three platforms - Windows, macOS, and Linux. I aim to work on the following during the project duration - 1) Increase the scope of missing data structures and algorithms 2) Adding methods to current data structures to extend their support in other research and engineering backgrounds 3) Implementing the C++ backend to provide high performance 4) Enhancing the documentation for make it more user friendly and easy to follow 5) Aggressively test the newly added as well as the existing code to achieve 100% coverage which currently is at 99%.
Currently, at the Ontario Institute of Cancer Research, Jenkins is being used to run the release pipelines and this project proposes moving the system into a more automated format – to use Docker containers with a CI/CD-based system. In the standard release process, as project code will be built and pushed to the main branch for each GitHub repository, as a result, multiple dependencies would also be triggered to be built as well. In this way, we will know if a change in a dependency has correctly integrated into the broader code base. A lot of this testing is done manually, so automating this system can make the time frame for making a release much smaller. With a continuous integration system, we will integrate these artifacts with the release ETL (Extract Transform Load) pipelines.
My proposed project aims to enhance the Borg ecosystem by tackling three main areas: Filter option in diff and extract view in Vorta, implement live binary tests in Vorta, and bootstrap a Borgmatic restore from nothing. These improvements will help users more efficiently and effectively manage their backups, improve testing processes, and facilitate disaster recovery. Firstly, I will implement a search function that allows users to filter files by search string in Vorta's diff and extract view. I will also add the "Change" filter to the comparison view, which will filter only removed, added, and modified files. This task also includes adding syntax to allow advanced filtering and filter by size range as a stretch goal. These enhancements will help users easily find and manage their backup files. Secondly, I will improve BorgBackup testing by implementing live binary tests in Vorta. Currently Vorta contains stdout and stderr mock files for the Borg JSON output of various commands for testing purposes but there’s no actual running of the commands. Moreover, it only supports one mock file while Vorta supports multiple Borg versions where output syntax may vary. This project aims to improve Vorta Testing by implementing live binary tests that run on multiple actual Borg versions/binaries. I'll also integrate live binary tests with Vorta's CI/CD pipeline. Finally, I will implement bootstrap functionality in Borgmatic to restore backups from nothing, enabling users to easily recover their data in the event of a disaster. I will implement this feature by providing clear and comprehensive documentation, which will outline the steps required to perform a Borgmatic restore from scratch. This will significantly improve disaster recovery capabilities and reduce the risk of data loss.
Survey.jl is a Julia package for survey analysis inspired by the R package 'survey'. It aims to address the unique challenges associated with the analysis of large survey datasets, such as weighting, clustering, and stratification. I will be completing the implementation of generalized linear models, adding support for more complex survey types, creating helper functions as needed, and helping to refactor parts of the codebase.
The Dbpedia property dbo:wikiPageWikiLink helps us to see for the articles which have the outgoing link to the Berlin_Wall article in their Wikipedia article i.e. the text of the Wikipedia article has the hyperlink present for the Berlin_Wall article. This forms an entity relationship between articles such that Berlin_Wall is the subject entity and the articles that point to it are base entities. However, it was found that only few of these articles had some other predicate relationship with the Berlin_Wall article. Currently, such relationships are extracted from tables and the info boxes. In this project, we aim to make use of the unstructured text on the Wikipedia page to find relations among entities. The goal of this project is to develop a framework for predicate resolution of wiki links among entities. I will be using some recent research work on relation extraction to achieve this.
.NET is a trending developer platform in the recent years. A .NET port or C# support is also requested multiple times by Haiku users throughout the years. This project aims to port the .NET runtime and SDK to Haiku and create Haiku API bindings for C#, making it possible not only for users to run existing .NET binaries/games on Haiku, but also for developers to create Haiku-native applications in an entirely new way.