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>Porting task of SIS library to Android with possible alternatives for the technologies which are not compatible with Android.</p>
<ul> <li>Working on the Photo Language Translation Project with Systers for the UN Peace Corps volunteers.</li> <li>You may contact me either via Email : <code>aditya.thiruvengadam@gmail.com</code> / <code>T.Aditya@iiitb.org</code></li> </ul>
<p>In some algorithms there is the need to compare two distances of two point pairs. Especially, computing distances on ellipsoid in Boost.Geometry used compare_distance() function, which need to calculate the actual distance of two geodesic segments on the ellipsoid. Boost.Geometry used Vincenty formula, the time complexity of this algorithm is hard to estimate and expensive.</p> <p>To reduce the time complexity, this project tried to use the following approaches:</p> <ul> <li><strong>Condition Division</strong>:Compute the Euclidean distances first, if the length of two segments are very close, defined not “far enough” means “very close”. then fall back to expensive geographic distance calculation otherwise return the result by comparing those numbers obtained by less expensive cartesian computation.</li> <li><strong>Calculation with Sectorial Area</strong>:Get cross-section through the center of ellipsoid and the geodesic segments, then calculate the sectorial area, which is easy to compare distances. </li> <li><strong>Calculation with Performing a local spheroid approximation and return the 2D distance by map projection</strong>:Perform a local spheroid approximation, then use methods of map projection to calculate the distances.</li> </ul>
<p>Btrfs (B-tree filesystem) is a filesystem uses Btrees as its main on-disk data structure. It is based on Copy-on-Write (CoW) principle which means it does copy only when a write request is sent or a modification is necessary. Btree is used most in filesystem, database system. In Haiku, Btrfs is currently support read-only, the codebase only shows the basic structure, read operations, it lacks of core tree manipulation code, write supports, and other features. The project ideas request supporting write features for Btrfs. This will be accomplished in the following steps: Setting up userland friendly development mode for Btrfs, implementing tree operations (splittings, CoW, etc), adding more Btrfs structures if necessary, implementing write-feature functions.</p>
<p>By playing around with the 2D Arrangement demo, users can have a visual and direct experience on what functionalities to expect from this module before diving into official documentations.</p> <p>The present demo program supports several geometric objects such as line segments. The main goal is to add the support of Bezier and algebraic curves, which enriches the functionalities of the demo.</p>
<p>This project aims to make compression and decompression a transparent process to the user, minimizing interaction with archives. In the vast majority of cases, compressed files are just an intermediary point between the user and his content. It is desired that the user will have full access to this content right from the start, rather than being given the indirect means available now (for example, file-roller selectively decompresses files and stores them in a hidden cache). Also, since dealing with archives is actually dealing with files, the user will be able to do this from the file manager.</p> <p>From the developer’s perspective, moving archive support to a library will allow for compression and decompression to be handled internally by applications. This aims to reduce the usage of file-roller so it can eventually be removed as an application.</p>
<p>Web Sites have evolved a lot from static mundane texts to interactive ajax based web sites and today’s Single Page Applications which provides user with a very intuitive experience. React has been one of the front-runner frameworks spearheading this more robust front ends rendering SPA frontend dramatically fast. This has been at the cost of getting down a barrage of javascript in the beginning and rendering it on the fly using the browser’s Javascript and rendering engines. This is counter intuitive to the User Experience goals of a single page application paradigm.</p> <p>A trivial solution that comes into mind is to push this workload to the server to process this Logic in the back end and send it to the server. This raises the concerns of the requirement of an Isomorphic JS backend such as NodeJS. However, with a back end that utilize Java 8 which comes packing with a much more advanced Javascript Engine - Nashorn, possibilities crop up.</p> <p>The main idea of this project wraps around finding an efficient paradigm to develop SPA’s by pre-rendering partially or whole HTML DOMs in the back end and delegating the basic DOM rendering of the static or partially static contents to the browser.</p>
<p>The ScholarLY 'annotate' module is a new tool, currently in a workable preliminary state, which extends the LilyPond music engraving software to add various implementations of textual annotations for collaborative workflows and the creation of critical editions. This project aims to improve functionality of the module within the LilyPond environment, and to extend the various outputs of those annotations. As such, the primary target features include triggering of score items from within annotations, ability to render score snippets in annotations, addition of new output file types of annotation logs (it currently supports plaintext and tex), ability to handle and export latex-ready footnotes, and the creation of a versatile LaTeX package (which does not exist yet in any state) for compiling the annotations (from the previously exported log) in LaTeX with customizable options for styling and distribution. Ultimately, 'annotate' offers a comprehensive functionality that hasn't yet been achieved in traditional/commercial softwares, and which will benefit a range of engravers from amateurs and individuals to professionals and group settings.</p>
<p>Mlpack provides an extensible, flexible exact nearest neighbor search implementation, with the ability to do dual-tree k-NN search. However, there is currently no support for approximate nearest neighbor search, despite its popularity. The aim of this project is the implementation of approximate K-NN search and then, work with the benchmarking system in order to produce rigorous comparisons between mlpack's approximate k-NN search implementation and other libraries, such as FLANN, ANN, or LSHKIT. Follow the progress of the project on: <a href="http://mlpack.org/gsocblog/author/marcos-pividori.html" target="_blank">http://mlpack.org/gsocblog/author/marcos-pividori.html</a></p>
The PyArrow project currently faces performance bottlenecks when used in astronomy computational work on massive datasets, such as the HATS catalog light curves. Specifically, the Apache Arrow C++ and PyArrow implementations struggle with parsing multi-level nested Parquet files due to underutilized multi-threading, lack the ability to selectively load specific fields from deeply nested structures, and feature compute kernels that do not support nested datatypes. This project aims to resolve these core issues to drastically improve load times and resource efficiency for the astronomy community.
Global financial entities, clearinghouses, and settlement networks require absolute precision in market scheduling to maintain operational integrity, compliance, and international goodwill. Currently, the open-source ecosystem forces developers and financial institutions to rely on expensive, proprietary APIs for this critical data. This project democratizes global market schedules by significantly expanding Holiday's financial coverage, implementing native, offline calendars for 15-17 new global exchanges across the Americas, EMEA, and APAC regions. Every newly integrated market will be mapped to standard ISO 10383 Market Identifier Codes (MIC), strictly researched for deep historical accuracy, and equipped with native localization (L10N) support.
-fbounds-safety is a C language extension designed to prevent out-of-bounds memory accesses. Currently, upstream Clang provides partial support for some annotations such as counted_by. The proposal aims to extend the scope of the currently supported annotations and upstream missing ones.
Cellfinder currently expects full 3D whole-brain volumes with both signal and background channels, so brain slices (2.5D) and single-channel acquisitions are not first-class citizens. The codebase also mixes axis conventions, which makes dimensionality changes error-prone. A recent data-loading refactor introduces explicit axis tracking and a new class hierarchy for cube generation and augmentation; the 2D/2.5D and single-channel work proposed here will build on that foundation. The core deliverables are to standardise axis semantics as the foundation, add a 2D detection path for brain slices and refactor classification to support both 2D and 3D inputs, and make the background channel optional across the main API and classification pipeline.
This project extends Dagger.jl with an MPI-based backend, allowing it to scale more effectively on high-performance computing (HPC) clusters that use low-latency interconnects like Infiniband or HPE Slingshot. Dagger already offers a productive way to express parallelism in Julia, using Directed Acyclic Graphs (DAGs) to schedule and run tasks. However, it currently relies on Julia’s Distributed.jl and TCP for communication, which becomes a bottleneck at large scales. In the exaflop era, where extreme-scale simulations demand both scalability and productivity, this limitation is significant. By integrating MPI, we build on vendor-optimized communication libraries to combine Dagger’s ease of use with the performance needed in HPC environments, much like frameworks such as Legion and Iris.
This proposal aims to improve the capability of markdown exporter package inorder to cover multicompartment model, and also to support generation of p.d.f, h.t.m.l , latex file types not only this but also to follow a standard template generation using jinja2 templates , Inorder to streamline the process for user to select the output according to their requirements based on their template selection. apart from this handling the python environment inorder to extend support for morphologies , moreover allowing users to use their own templates from their file system, which enables them to make the best use of brian2tools package.
The ‘Open Source Community Sustainability’ project is about simulating open-source community interactions to encourage conditions leading to sustainable practice. I propose to do this by creating a framework with an agent-based model powered by Large Language Models (LLMs). This project has been worked on in OREL for the past 2 years, and a variety of models and tools have been created towards it, utilizing reinforcement learning, active inference and attraction-repulsion based approaches to build several agent-based models. Thus, this framework will represent open-source communities as a system composed of interconnected components (agents), mapping the intricacies of community engagement and collaboration as well as focusing on emergent properties and overall system behaviour. This project is important to the open-source ecosystem because as the demand for open-source software continues to grow, so do the challenges associated with community management, collaboration, and sustainability. Thus, providing a framework to understand how individuals collectively contribute to community growth and success can help derive insights into effective community management, collaboration strategies, and sustainability factors.
The project focuses on streamlining the debugging and development process for code intended for offloading to devices like GPUs. It proposes a method to execute offloaded code in a separate CPU process on the same host, simplifying debugging and avoiding the need for a GPU setup. The work involves creating a host-ISA offloaded code generation mode and a libgomp plug-in to interface with the libgomp offloading machinery, managing the new process for the offloaded code. This approach can simplify debugging issues related to memory mapping or multi-device offloading, and potentially simulate GPU-like parallelism using CPU threads for a broader range of debugging scenarios.
Deploying AWS Lambda functions using AWS SAM (Serverless Application Model) requires manual creation of a deployment descriptor, posing challenges for Swift developers due to learning a new DSL and adopting new tools like SAM CLI and Docker. To simplify this process, the community proposed a Swift-based DSL and a Swift package plugin. However, these solutions rely heavily on accurately mimicking the evolving SAM AWS deployment descriptor. To address this, this project proposes to automatically generate the AWSLambdaDeploymentDescriptor library based on the SAM template definition. That generated code is used by the Swift-based DSL to create SAM YAML templates required to deploy Lambda functions and their dependencies to AWS.
MetaCall offers binaries and a CLI that can be downloaded and installed easily through metacall/install. This provides a CLI for executing code and a REPL for interacting with some MetaCall functionalities. Apart from this, there are two separate projects that are part of the full development lifecycle: metacall/deploy, which is a CLI for deploying into the FaaS and metacall/faas, which is a reimplementation of the FaaS for local development. These two tools are right now completely separated from the CLI, although they are necessary for the full development lifecycle. The idea of this project is to unify them into the same project. For example, having metacall deploy ... for executing the deploy CLI or metacall faas for executing the FaaS locally. With these options, all tools will be unified into one, and end users will install all of them once the CLI is installed.
This project aims at building an Api based on knowledge panel of Open Food Facts that return client a specific knowledge panel with use of one or two facets its Provides applications with a set of informative or actionable items which are contextual to a specific facet ,the primary goal is to allow high level contributions by users that maybe interested in a particular subset of the database, like a particular food category or a brand, a location, etc...,its reuse the knowledge panel format, which remove the need for the application to change as the server side code change, or to implement specific business logic.
Currently the documentation for the Syntax of the various SQL’s that Polypheny supports has text based format which proves rather hard to read. The goal of the suggested project by Polypheny was to create a mini system which can convert the BNF like syntax in the markdown into a more visual representation in the form of railroad diagrams. With this I would like to extend the project into a large Project to apply the implementation of this Framework to the existing Jekyll Process of rendering so that it shows up as required on the website. I would also like to pursue possible extensions to improve the syntax completion and highlighting in the query console in the Polypheny-UI.
<p>Apache SkyWalking already has a Python Agent with relatively complete functions, but it still has some functional deficiencies compared with Java Agent. One of these is the ability to profile running projects. In this project, I will implement the profiling function for the Python Agent of SkyWalking. Because the Java Agent already implements this functionality, so the code in the oapserver and the report protocol can be reused, but the Python Agent needs to implement the code that accepts the profiling task command and the code associated with the profiling sample.</p>
<p>This project aims to provide Ceph users with the ability to report issues directly from the Ceph-Dashboard UI and attach all the available information to the report.</p>
<p>The Beacon specification allows to query whether a genomic variation is present in a repository. But the current implementation is based on an outdated version of this specification. Many new parameters that are useful for filtering down the data which can improve the querying experience are available according to the latest specification. To improve this querying experience and search results, I would be updating the existing implementation, so that it matches with the current specification.</p> <p>Also, current variation search APIs retrieves all the fields together. This is a lot of information at once and is cluttered. So, I would be redesigning these APIs and would make it closer to RESTful principles.</p> <p>Now, variation search by 'geneId' is not efficient. To deal with this issue, I would build a data pipeline that would load mappings from a 'geneId' to its coordinates. These coordinates would then be used to search for variations.</p> <p>I would be also be adopting the models defined by VMC which would enable standardized exchange of genomic data.</p> <p>Based on the work done, feed backs will be provided to GA4GH workstreams.</p>