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>The javascript code is written in ES5 exposing many of the variables and functions globally and the package manager is not used for the modules. So I will work on implementing package manager for modules like jQuery, jQplot etc which are being used in phpMyAdmin, transforming ES5 code to ES6 which has new features block scoped variable defining, classes and dynamic import-export, babel compiler for compiling ES6 code to ES5 which browsers support. The functions will also be converted into modules which makes it easier to import the required function only. This will help in making the functions unit testable. I will also implement webpack which will bundle the static JavaScript files and also minify them, which can be loaded as scripts.</p>
This project aims to build a platform to see BIM models and their corresponding metadata both in an android 10’ tablet and on the Liquid Galaxy Cluster. The models will be shown in a scene created with the Unity Engine, that is a game development engine. With the tablet it will be possible to look and interact with the scene using augmented reality. The android app will also allow you to open the scene on the Galaxy cluster and when this option is chosen a new screen will be opened with a controller for the scene. The scene that will be running on the galaxy will be a WebGL scene, so for that a chromium based project will be developed using Node Js. The node app will interact with the Liquid Galaxy using web sockets and in this way it will be possible to synchronize the displays.
This project is about porting the KDE Plasma desktop to run with the musl libc implementation. Many libraries and applications use "glibc-isms" and therefore cannot compile with musl. This is because musl strives to be a standards-compliant libc implementation which, unlike glibc, doesn't add additional things outside of POSIX. This will be solved by patching out all glibc specific code in software and publishing these changes upstream, and also to the Gentoo repository so already stable software can compile with musl correctly, without waiting for upstream. My deliverables will be having the KDE Plasma desktop & most of the KDE Applications running correctly and passing tests. Documentation for developers wanting to port glibc software and documentation for users for using a Gentoo+musl system will also be added to the Gentoo wiki.
<p>Information obtained from an <strong>Inertial Measurement Unit</strong> (IMU) is constrained due to physical limitations such as noise, drifts, misalignments and offsets. Since obtaining the state of a robot/vehicle requires integrating IMU outputs with time, the errors in the integrated estimates grow very fast. This project develops tools to accurately <strong>model the errors</strong> that affect IMU outputs, to <strong>estimate their relevant parameters</strong> and to understand <strong>how each parameter changes with time</strong>. Additionally, a <strong>sensor-fusion based pipeline</strong> is proposed for <strong>regularly correcting the estimated IMU parameters</strong>. The proposed method does not require any external mechanical setup and is designed to ideally work on low-computation processors and/or microcontrollers.</p>
<p>ArviZ is a python package for exploratory analysis of Bayesian models. It is designed as a backend agnostic tool and supports different backends for visualisation and diagnostics. Apart from plotting ArviZ also supports functions for posterior analysis, model checking, comparison and diagnostics.</p> <p>As ArviZ is mainly a visualisation library, it already has various plotting functions to analyse Bayesian Inference data. Still, it would be nice to extend its visualisation capabilities and add some more plotting functions which the community could use.</p> <p>This project aims to implement dot plots, quantile dot plots, half-eye plots, ecdf plots, and, if time permits, then also calibration plots for classification into ArviZ for both the backends Matplotlib and Bokeh and also to write tests for all these plot functions.</p>
The project proposal is to bring password-less authentication to Plone 6 by implementing WebAuthn, a password-less web standard by W3C. The proposal suggests that the implementation should allow the user to decide whether to use WebAuthn as the primary or second-factor authenticator. WebAuthn uses public key cryptography to store user credentials, which makes it more secure than traditional password-based authentication methods. However, the proposal also discusses the challenges of using WebAuthn, such as the Scenario where the authenticator device is not available or lost. The proposed solutions include backup codes, recovery codes, and administrator reset, but all of them require storing some kind of secret on the server, which is a security concern. The proposal suggests alternative solutions like encouraging users to use at least two different Authenticating devices to register.
This project aims to resolve Issue add blas bindings and implementations for linear algebra by systematically adding the missing Level 1, 2, and 3 BLAS math routines to the @stdlib/blas/base/* namespace. To ensure speed and backward compatibility, every new routine will be split into two parts: a pure, low-level math engine and a simple, user-friendly classic API.This architectural split empowers the underlying math engine to safely handle complex, non-contiguous memory layouts and apply strict cache optimizations using explicit strides. Meanwhile, the classic API acts as a protective shield, automatically calculating the required memory offsets (e.g., negative strides) to deliver a seamless and intuitive developer experience.
<p>This project focuses on the study and implementation of Graph Neural Networks (GNNs) for low-momentum Tau Particle Identification using the CMS Open Data. The algorithm will further be deployed on CMSSW (CMS Software) inference engine for use in reconstruction algorithms in offline and high level trigger systems of the CMS Experiment. The project also aims to compare the results of GNN based algorithms with the CNN (Convolutional Neural Network) based algorithms for tau particle identification. Finally, the graph neural network algorithm will be scaled to multiple GPUs and optimised accordingly for efficient training and inference using heterogeneous computing. The final inference performance on the CMSSW inference engine will be benchmarked facilitating the end-to-end low-momentum tau particle identification.</p>
<p>gopy is an excellent tool which generates (and compiles) a CPython extension module from a go package. And I hope more developers could make full use of gopy to migrate their go code into python code. To make gopy more advanced, It is necessary to provide APIs for various Python compiler versions, such as CPython 2/3 and PyPy. This can be improved with CFFI or ctypes. Moreover, many go’s implementations/features are not yet implemented in gopy. So we need to implement implementations such as slices, interfaces, and maps in the go.</p> <p>My goal is to update gopy by using CFFI to support Python3 and PyPy and write detailed documents.</p> <p>Github: <a href="https://github.com/go-python/gopy" target="_blank">https://github.com/go-python/gopy</a></p>
Automated software engineering helps developers of control software to manage complex industrial applications. Eclipse 4diac has, in recent years, advanced in terms of providing tool support for domain experts. The control software is typically executed in real-time and distributed across devices. Designing such systems is complex due to the need for communication between devices. To detect faults early, modeling implicit assumptions within IEC 61499 software can provide the basis for automated checks. Such assumptions are typically described in constraint languages, which are difficult to use by automation experts. Therefore, this project provides the infrastructure for tool-assisted communication engineering. Where user interactions are required, graphical visualizations are provided. Current infrastructure for generating automated communication does not support the variety of communication protocols that is observed in modern automation systems.
<p>PRocess MONitor (PRMON) is a utility programme used by the Worldwide LHC Computing Grid (WLCG) to monitor the resource consumption and performance of millions of jobs run by the ATLAS experiment in particular. The output generated is then used to detect anomalies in individual jobs or task groups. As the functionality of PRMON is extended, the complexity of errors that need to be tested and handled increases. Further, it is presently designed to read the data of processes while they are running. This project aims to implement a logging framework for dynamic and configurable logging. Further, the functionality of PRMON will be extended to read data from preprocessed sources. Each monitor will be adapted to read optionally from these precooked sources. The unit test infrastructure will be developed for testing against complex and unusual errors. Precooked sources will be generated to serve as unit tests consisting of these unusual cases.</p>
Training Large Language Models (LLMs) is computationally expensive, often bottlenecked by the performance limitations of Python-based frameworks. This project addresses this challenge by enhancing LLM training efficiency within a C++ environment through the integration of Clad, a Clang/LLVM compiler plugin for automatic differentiation (AD). We will deveop a custom C++ tensor library specifically designed for optimal interaction with Clad. The core objective is to replace traditional runtime or manual gradient computations with Clad's efficient compile-time differentiation for key LLM operations within a GPT-2 training pipeline. This involves investigating effective strategies to bridge Clad's static analysis with dynamic neural network computations, benchmarking the resulting performance gains in speed and memory usage against a non-Clad baseline, and leveraging OpenMP for further parallelization.
<p>Compiling taxonomic checklists from varied sources of data is a common task that biodiversity informaticians encounter. Data for checklists usually occur within textual formats and significant manual effort is required to extract taxonomic names from a given text into a tabular format. Textual data in sources such as research publications and websites, frequently also contain additional attributes like synonyms, common names, higher taxonomy, and distribution. This project aims to facilitate a quick extraction of textual data into tabular lists from various sources including given files in different formats, as well as biodiversity websites which have an iterative subpage structure. It realizes an easy aggregation of biodiversity data in a structured format that can be used for further processing and upload onto data aggregation initiatives and help in compiling biodiversity data.</p>
This project proposes a modular, real-time gesture-to-sound mapping framework for the GestureCap system. It will enable users to translate hand gestures into expressive audio control for music and speech applications. The system introduces a mapping engine that sits between gesture recognition (via MediaPipe in Python) and sound generation (in Max/MSP). The engine will allow users to define how gestures control sound using deterministic mapping (rule-based), learned mappings (customizable, ML-based), and hybrid mappings combining the two. It will emphasize real-time performance, flexibility, user-friendliness, and reusability with mappings that can be saved/loaded as JSON files. This project will enable rapid prototyping of gesture-controlled musical instruments and other sound generation for creative as well as research-oriented objectives.
<h4>Dataplane batching</h4> <p>FRRouting uses the concept of a data plane which is the part of the code that processes thedata requests. It is used in communication with kernel i.a. to update routing tables. There areseveral different methods for reading kernel routing table information, updating kernel routingtables, and for looking up interfaces. One of them is Linux Netlink - asynchronouscommunication between kernel and user. FRRouting with its dataplane abstraction, uses aqueue of dataplane context objects for messages waiting to be sent. A separate thread loopsover this queue and sends the context objects to the appropriate dataplane. Every singlemessage is handled and sent separately, but there’s room for improvement. Certaindataplanes allow for sending multiple messages to them at once, so we could benefit from it.This would improve overall processing time. My proposal will involve implementing one ofthe proposed ideas, namely “Dataplane Batching”.</p>
A language server is what makes it possible to rich editing like to go to definition or code completions in source code editors. The Solang Solidity Compiler does have a language server, but it is very rudimentary. The aim of this mentorship is to make the language server much more complete, will make developing Solidity code using this language server will be a much greater developer experience. During this mentorship you will learn how language servers work, and you'll need to walk the parsed Solidity abstract syntax tree in various ways to for example find where a variable is defined (Go to definition), or to find all usages of a variable (Find all references), or find the type definition (Go to type definition). This means walking a complex data structure, and understanding how source code is represented as a abstract syntax tree, which is the result of parsing and semantic analysis, the first stage of an compiler.
NetBSD is capable of running binaries compiled for Linux through a thin in-kernel translation layer, the Compat Linux. Currently, the Linux emulation is not covered by the NetBSD test suite, this project aims to target that area, focusing on testing the syscalls emulations. To achieve this, the syscalls tests from the Linux Test Project will be used. They will be compiled for Linux and the resulting binaries will be run with the Compat Linux. This project will focus on the most basic/used syscalls, this allows for a great coverage of use cases, and will make running more complex tests easier in the future. The syscalls to be tested are: Basic IO: read, write, open, close, lseek, stat, fstat Processes: fork, execve, exit, waitid, dup, dup2, pipe Memory: nmap, munmap, mprotect, brk Sockets: socket, bind, connect, accept
<p>PortfolioAnalytics is a popular R package designed to provide optimized solution and visualizations for portfolio allocating problems with complex constraints and objectives. In order to finish the optimization tasks, it contains many solvers from other R packages. In the summer of 2019, I implemented three optimization engine into PortfolioAnalytics package. I implemented Rglpk as an advanced linear programming problems solver to manage assets objective to the ratio of a portfolio return over its expected shortfall. I implemented osqp as a more involved quadratic programming problems solver to build a portfolio according to Modern Portfolio Theory, and generate efficient frontier as a preference for users. I implemented mco as a progressive multicriteria optimization tool to satisfy portfolio managers' complex needs. With the effort of these new engines, the PortfolioAnalytics is able to solve the optimization problems precisely, fast, and squeeze all possible profit.</p>
<p>Zoner Draw is a good and easy to use vector graphics editor. Its development stopped several years ago and the last version (5) was released free of charge, which makes it a good choice for students, beginners etc. Unfortunately it can save documents only to its own format (ZMF), so it would be great for LibreOffice to support importing from this format.</p> <p>There are two variants of the format: one is used in the recent versions of Zoner Draw (4-5) and another, based on OLE2, was used by older versions (2-3). The most important parts of both formats have been already reverse engineered and available in OLEToy, but a bit more reverse engineering will be needed to reveal the missing parts.</p> <p>Similarly as for other import filters implemented in LibreOffice (libcdr, libvisio, libmspub, …), a C++ library (libzmf) based on librevenge will be implemented.</p>
<p>‘Effective Python routines for analysis on massively multi-threaded platforms-Python bindings for the Hydra C++ library'. The title of this project suggests that we need effective Python routines for some kind of intensive heavy-duty data analysis on multi-threaded platforms. It also suggests that Python bindings for the Hydra C++ library. Hydra library is a C++ header-only library which is used for high performance and precision. Since in this project, we are writing Python package for the binding of Hydra library, we can expect to have the dynamicity of Python combined with the performance and precision of C++. In large experiments when we have terabytes of data to perform analysis on we need performance and at the same time, we want tools which are not too hard to use. Keeping this in mind, after completing this project we can expect to have such kind of Python package which anyone can use without any performance and precision lose.</p>
LitmusChaos is an open-source chaos engineering platform for Kubernetes, enabling users to test and improve the resilience of their cloud-native applications. The task is add unit tests for Chaoscenter Web and test cases for the Authentication Server. The GraphQL API documentation will be updated with the latest APIs, while the GraphQL server's APIs and handler functions will be optimized to reduce code duplicacy. Additionally, comprehensive documentation and video tutorials will be created for local development setup, promoting easier onboarding and collaboration. - Expected outcome: The expected outcome of this issue is an improved Chaoscenter Web and Authentication Server with added unit tests, updated GraphQL API documentation, and optimized APIs and handler functions. The enhancements will result in a more reliable, efficient, and user-friendly chaos engineering platform, promoting better collaboration within the community.
<p>Public access to communications is an important aspect to some communities. These communities may or may not be open source communities but still might desire that people on web should be able to access their communications without the need getting an account. With this project we want Zulip to become capable of serving chats that happened in public streams to anyone on the web. Essentially one will be able to read the chats of a web public stream. Members of such a stream will consent to terms of publishing their conversations online. Also this project will help search engines index public chats that happened on a Zulip server accessible to anyone on the web. This will greatly enhance the support available for debugging issues with Zulip installations since we can expect solutions provided on Zulip developers chat to pop up in search results of a search engine query.</p>
<p>Cytoscape is an open source software platform for visualizing molecular interaction networks and biological pathways. It integrates these networks with annotations, gene expression profiles and other state data. Visualizing a complex network requires a great deal of calculations, thus takes a long time to render large networks with original software-based engine. This project aims to replace the original Cytoscape-2D engine with one taking advantage of high speed GPU calculation and delivering much better efficiency. The proposed project’s goal is to build an optimized renderer that works faster with rendering a large network, has the ability to draw more nodes and can be displayed better on high-resolution screens based on previous work. Additionally, as the low level of Cytoscape System, the new renderer should be compatible with the system while easy to maintain and test.</p>
The requirement of this project arises because currently each donation made to NetBSD electronically from PayPal and Stripe are handled manually using Request Tracker and tickets. The person handling the tickets needs to extract the donation details and enter them into the acknowledgement form and send it to the donor. Further the donor can decide if they want to be listed on the public list of donor and inform by a mail. This process involves manual intervention which may result in error and/or delay. Therefore, if an automated system can be made that handles all these tasks, it will speed up the process, reduce errors, and also save time and energy of the person who performed all these tasks. The primary goal of this project is to develop a system that automates all these processes : acknowledgement of the donor, storage of donation details in the database(to be created) and updating the public list of donor on the official NetBSD website based on the response received form the donor through the online feedback form.