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.
This proposal aims to implement HTTP/3 communication for Dubbo Triple in the Go language environment, enhancing the connection management capabilities of the Triple protocol in dubbo-go. The proposal will address the compatibility issues between Triple communication in dubbo-go and dubbo-java by implementing keep-alive functionality at the Triple protocol layer. Additionally, the proposal plans to organize and standardize the error codes of the Triple protocol and output necessary log information. By developing a Triple HTTP/3 server and client, seamless and high-performance communication between Dubbo Java and Dubbo Go over the HTTP/3 protocol will be achieved. We will design a connection pool to effectively manage Triple connections and ensure the validity of connections through a PING-PONG mechanism between the server and client, thus realizing keep-alive functionality. Furthermore, the error codes of the Triple protocol will be standardized according to Dubbo Java's standards to facilitate developers in obtaining detailed log information during the debugging process. The final deliverable of the proposal is to achieve high-performance, barrier-free communication between Dubbo Go and Dubbo Java through the Triple protocol, ensuring perfect compatibility and support for interaction via the HTTP/3 protocol. Users will be able to enjoy flexible keep-alive functionality and improve debugging efficiency through standardized error codes.
In order to streamline releases, we are planning to ensure that all critical user journeys (CUJs) on the Oppia web application are covered by acceptance tests. This is important because it will provide assurance that, on the merge of every PR, these critical user journeys still function correctly, which means that no major breakages will result if the develop branch gets deployed to production. Additionally, having a complete set of acceptance tests that are organized by CUJ makes it easier to audit whether or not a particular CUJ has been included, and it also helps developers add tests for new CUJs while still keeping the tests well-organized. This project includes: Writing acceptance tests for the as-yet-uncovered CUJs in a way that keeps the tests organized and maintainable. This might also include small updates to the acceptance test framework, e.g. extracting utility functions to enable code reuse or providing relevant functionality for a group of tests. Tightening all page utility functions to have pre/post checks (in the form of "wait" statements) and proper error messaging, so that it is easier to debug flakes. The pre-check wait ensures that the conditions are good for performing the action, and the post-check wait ensures that the action has fully completed. Deleting e2e tests whose functionality has been fully replaced by the acceptance tests.
The Tor network's anonymity guarantee depends heavily on the connectivity between relays. Partitioning in the network can significantly compromise these guarantees by limiting the possible paths available to users. During GSoC 2023, the eRPC tool was built to detect such partitions by building two-hop circuits between relays and storing the results in a Neo4j graph database, where vertices represent relay fingerprints and edges represent successful or failed circuit builds. This project aims to enhance the existing eRPC tool by developing analysis capabilities to detect, visualize, and understand network partitions. The focus will be on implementing efficient graph algorithms to identify disconnected components and communities within the Tor network. By utilizing Neo4j's Graph Data Science (GDS) library, we can apply community detection and clustering algorithms to find potential partitions in the directed graph that represents the Tor network. By the end of the project, I aim to deliver an enhanced eRPC tool with robust analysis capabilities, interactive visualizations, and comprehensive documentation. This will provide the Tor community with valuable insights into the network's connectivity patterns and help identify areas that need attention to strengthen Tor's anonymity guarantees.
The need for a new Javadoc parser has been raised repeatedly, particularly in response to persistent performance bottlenecks and maintainability concerns with the current implementation. This project introduces an ANTLR-based grammar to replace the legacy parser used in Checkstyle. The current parser has proven inefficient, difficult to extend, and prone to inaccuracies—especially as Javadoc syntax evolves. By adopting a modern grammar-based approach, we aim to significantly improve parsing performance, accuracy, and long-term maintainability. All existing Javadoc checks will be adapted to work with the new AST structure, ensuring full backward compatibility.
This proposal addresses the implementation of a scalable recurring events system for Talawa, focusing on efficient data management and association handling. Current event management in Talawa lacks support for recurring events in postgres branch, a critical feature for organization planning. The previous implementation faced scalability issues, particularly with memory consumption, transaction timeouts, and database bloat and no implementation to handle association like (action items, agenda items, attendance, etc). The proposed solution introduces a "Temporal Sliding Window with Inherited Associations" approach that: Separates recurrence patterns from event instances Uses a materialization window to pre-generate near-term events Implements an association inheritance model to minimize data duplication Employs background processing to maintain system performance
The goal of this project is to expand the Unikraft ecosystem by enabling the execution of popular applications through binary-compatibility mode. Currently, many popular applications are not supported on Unikraft, and this project will address that gap by integrating these applications into the Unikraft catalog. I will work on adding a variety of applications, such as SQLite, Mosquitto, Traefik, and others, to the Unikraft catalog. The project will also involve extending or adding new system calls to ensure proper functionality and writing automated GitHub workflow files. This project will significantly enhance Unikraft's application compatibility, making it more attractive to developers and helping grow the Unikraft community.
Libreoffice uses its own GUI Library VCL, which interfaces with various backends like GTK, QT, Windows UI, and macOS X UI. VCL gets colors for the UI from these toolkits(the operating system colors), and using a pair of Get*****Color() and Set*****Color() can customize them, but these customizations are limited. And thus it has to use system colors for other UI elements, which is limiting. The Idea is to introduce the concept of themes so as to make application colors independent of the Operating System Colors, and make themes available via extensions.
A web interface in which you paste a C header in a textbox on the left, and it outputs dart:ffi bindings generated by package:ffigen in a textbox on the right. (Inspiration is https://godbolt.org/ which does this for a C file on the left and assembly on the right.) In order to avoid needing a server to do the backend, we'd like to compile the Dart code in package:ffigen and libclang to WASM. That way everything can run in the browser.
The issue is to address the usability and accessibility limitations of GDB by developing a user interface (UI) utilizing React. This UI will leverage the GDB Python API to create a graphical dashboard that streamlines the debugging process. By providing a more intuitive and visually interactive interface that aims to enhance the debugging experience for developers, making it easier to execute commands, examine program state, and control operations within GDB. It contains features such as starting/stopping program execution, inspecting variables, registers, and memory, and a log or console view for command output and error messages.
Scribe is a keyboard application for language learners. It sources its data from Wikidata. 1. Adding a menu to the application: - Currently, the Scribe application only displays the installation guide and a link to the open-source repository. - The design for the menu as seen in the figma file found in the repository of Scribe-iOS suggests the creation of multiple different screens that navigate to sections -- Installation, Settings, About and further sub-sections. - We can assume a simple navigation stack where the bottom most layer is the main ViewController. This is achieved using a NavigationController on the first view that is presented. 2. Adding more languages to the application - The data used by Scribe-iOS is generated and processed in the Scribe-Data project repository. - The deliverables here will include generating data for all the planned languages that need to be added to Scribe, cleaning and processing data to obtain language data files, creating and assigning corresponding files and variables in Xcode for all languages and user testing.
Currently, GCP Scanner does not support the parallel enumeration of GCP resources and parallel scanning of GCP targets. This project is aimed to address this shortcoming. Also, GCP Scanner has one giant scanning loop from where it launches GCP resource crawlers. We need to split each crawler into individual modules with proper error handling that will improve code readability and quality. We can leverage python classes for the state of execution control, config parsing, and enabling/disabling certain functionality in the scanner.
This project is being proposed to redesign and update the official site for BRL-CAD, which will add more details to the site related to the organization. The project will be made using the latest technologies like React, Hugo, or other site generators. Another important aspect of the project would be to make this documentation on GitHub more accessible (https://github.com/BRL-CAD/brlcad-docs/).
<p>This project is about extending Ruma's API coverage. The final goal for this project is to have a more complete coverage of the Matrix spec, along with implementation of two recent MSCs in Ruma.</p> <p>The three main milestones for the project are the following:</p> <ol> <li>finishing <a href="https://github.com/ruma/ruma/milestone/3" target="_blank">identity-service-api</a></li> <li>implementing <a href="https://github.com/ruma/ruma/issues/479" target="_blank">MSC2403 (Add "knock" feature)</a></li> <li>implementing <a href="https://github.com/ruma/ruma/issues/478" target="_blank">MSC1946 (Secure Secret Storage and Sharing)</a></li> </ol> <p>However, other tasks are part of the project schedule. These are of a smaller scale, but aim to help me get more familiar with the code base, or just generally improve Ruma.</p>
<p>This proposal aims to bring scripting support to SwiftPM. The goal for GSoC is some kind of proof-of-concept and is expected to be the foundation of a full implementation of this feature. The outcome is expected to be a prototype of the new <code>swift-script</code> tool, which has a limited set of basic operations implemented like <code>run</code> and <code>reset</code>. There will also be a new flag for Swift Driver which enables a shortcut to the feature through <code>swift</code> command.</p>
<p>LibreCAD 3 is the new version of LibreCAD currently under development. LibreCAD 3 uses Lua for GUI initialization, management, plugins and for the various create and modify operations, allowing easy addition of functionality and extensibility through Lua. Lua for GUI initialization and management has a couple of disadvantages like lack of unit tests, compiler checks and more difficulty debugging. Users writing plugins for the GUI require knowledge of the Qt C++ framework. This project aims at shifting the GUI initialization and management to C++ while also providing an alternative API for the GUI for plugins.</p>
<p>Boost is one of the most fundamental collections of C++ libraries, powering thousands of projects, but also driving the development of C++ best practices and C++ standards. Boost.Multprecision is the Boost library providing number types with precision higher than that of C++ built-in types. The library offers support for integer, floating-point and rational data types at compile-time fixed, arbitrary and variable precision.</p> <p>Currently, many operations are already supported for arbitrary precision, but tests exist only for up to 1024 bits. The purpose of this project is to 1) extend testing for precision of thousands of bits and 2) add arbitrary-precision support for more complicated functions and constants. This includes adding tests for arithmetic operations of higher precision, extending tests for simple functions, extending special functions to higher precision, adding support for higher precision constants (and adaptive precision algorithms) and optimising several of the operations (see Milestones for details).</p>
<p>The ODK-X Push Notifications project consists of two applications currently code-named "Skunkworks-Parrot" and "Skunkworks-Bat" .“Parrot” is the desktop application, that provides a user interface for writing messages, creating user groups to receive them, and sending those messages via the Firebase Cloud Messaging. “Bat” is the Android application that receives these messages via Firebase and displays the message to the user. In this project, I will be working on migrating databases from the firebase realtime database to the sync-endpoint sever. I will be also adding some new features to both Desktop and Mobile applications to improve user experience.</p>
<p>As direct as possible, the goal with this project is to <strong>make more of Git’s codebase thread-safe</strong>, so that we can <strong>improve parallelism in various commands</strong>. The motivation behind this are the complaints from developers experiencing slow Git commands when working with large repositories, such as chromium and Android. And since nowadays, most personal computers have multi-core CPUs, it is a natural step trying to improve parallel support so that we can better use the available resources.</p> <p>With this in mind, pack access code is a good target for improvement, since it’s used by many Git commands (e.g., checkout, grep, blame, diff, log, etc.). This section of the codebase is still sequential and has many global states, which should be made local, removed or protected before we can work to improve parallelism. That's what this project is targeting.</p>
<p>A changepoint is typically defined as a point in time where the distribution of a data-stream changes in a distinct manner, for example, typically one may look for changepoints in mean, and/or variance. Usually, this is performed in an unsupervised setting where we have no labelled examples of true changepoints. However, in practice, we usually have examples of periods of time where we know no changes should be present, or conversely where changes are expected to exist. When and where such information is available, we can potentially use this to aid our judgement of how to set complexity penalties in the changepoint estimation task, and thus, decide on an appropriate number of changepoints, a task which currently requires time-consuming parameter tuning by domain experts.</p> <p>In this particular project, we seek a simple visualization interface to support, i) human labeling of the data with the aid of several complementary measures on the data-stream such as as mean, trends, min, max, variance, etc. and ii) interactive exploration of the result space suggested by a changepoint detection algorithm. Eventually, any visualization will help communicating the data and respective decisions.</p>
<p>Developer Web Interface for ReactOS will be a single Interface which can address all developer needs from easily watching commits to triggering tests and viewing test results. The interface will be having all details regarding the GitHub repository of ReactOS ranging from commit history to pull requests with the ability of filtering. Moreover, the interface will allow the developers to view the build and test results with details by taking the help of existing ReactOS web tools</p>
<p>A C++ adapter API for integrating vectorized components in a scalar workflow.</p> <p>Many FLOP-intensive algorithms may profit from the vector pipelines of modern processors; they don’t because they don’t have vectorizable inner loops. The project idea is to implement and benchmark a generic vector flow service that can non-intrusively integrate with arbitrary data processing frameworks and can expose algorithms to the higher-level event loop of these frameworks.</p> <p>This library aims to provide an API and a set of examples demonstrating the transformation of the scalar algorithm in a vectorized one. Depending on the intrinsic algorithm gain from SIMD vectorization and better data caching, the overheads introduced by the extra data transformations can be much smaller than the benefits.</p>
<p>The Internet Archive is a non-profit library committed to Universal Access to Knowledge. In its 23 years of operation, the Internet Archive and its community have archived millions of web pages, books, texts, audio tracks, videos, images, and software. These items are made freely available to the public to consume and repurpose through the Internet Archive’s flagship website, Archive.org.</p> <p>However, in the midst of the Archive's archiving efforts, it is imperative that users are able to easily navigate through the website's content and find what they are searching for, regardless of the device used or disabilities that they may have to contend with.</p> <p>Thus, the following project aims at improving Archive.org's navigation by researching, prototyping and developing relevant components at IAUX, the Internet Archive’s monorepo for Archive.org UX development and prototyping.</p>
<p>The core of the proposal is a <strong>wide improvement of the LaTeX integration</strong> with JabRef, <strong>focusing on the end-user</strong>, whose characteristics have been studied before: 69% use LaTeX and 87% are researchers.</p> <p>The goal is to make the work easier for our users. I will develop several tools for <strong>analysing and checking LaTeX text documents</strong>: finding bibliographic entries (which are used, how many times, and where) and counting words, characters and citations by document; validating TEX files for solving issues; and importing entries from TEX files.</p> <p>Additionally, if time permits, I will add support for <strong>connecting to JabRef from external editors</strong>. Therefore, it could be possible to search a specific entry from TeXstudio.</p> <p>This feature will be integrated in the next major release (version 5.0) and should be available to the users.</p>
<p>Open Event Organizer is an Android Application for Event Organizers and Entry Managers. It is a client side application for another project under FOSSASIA named Open Event Organizer Server.</p> <p>The core features implemented in the app are:</p> <ul> <li>Scan a QR code to validate an attendee's check-in</li> <li>Overview of Sales</li> <li>Ticket Management</li> <li>Edit Basic Event Details</li> <li>Offline Support to the above-mentioned features</li> </ul> <p>The app is designed on the Model View Presenter Architecture which enables robust unit testing. Each feature implemented in the app has a complete coverage of unit tests. The app uses most of the modern open source technologies like ReactiveX API for multithreading, Dagger for dependency injection, OkHttp+Retrofit for handling network requests, Evernote's android-job for handling jobs in the background, JSON API-converter to handle JSON API schema responses, Google Vision API for scanning QR code, Glide for image loading/caching, Jackson to parse JSON data, Leakcanary to detect memory leaks, Lombok for logs, Mockito Framework for unit tests, DbFlow ORM database library, Data Binding etc. Material Design Guideline is followed for the UI in the app.</p>