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.
Pwndbg is currently tied in many aspects to GDB. While this is fine for many uses cases, GDB isn't a first-class debugger on many platforms, such as macOS and, as of recently, Android. This project aims to make Pwndbg support LLDB by leveraging its Python API - in the same way the GDB Python API is currently used, and to refactor Pwndbg to be more backend-agnostic, so that porting it to other debuggers will be easier in the future.
PyZombis is a community course designed to teach Python to the Spanish-speaking community, based on the Brazilian MOOC "Python para Zumbis." The idea is to create an improved Spanish version with an interactive environment for students, using the Runestone library to visualize and try active code. Currently, PyZombis uses the Brython Interpreter, which lacks support for modern libraries like Pandas and Numpy. To overcome this, I propose integrating PyScript, enabling rich Python applications within the browser and providing access to more libraries. Additionally, PyZombis requires database functions for authentication and tracking user progress. I plan to create a SCORM (Sharable Content Object Reference Model) compliant package and use it with an LMS like Moodle to monitor and track progress by integrating it with PyZombis.
<p>Currently , Tardis has the capability to store the state of model to an HDF5 file. This project , is mainly concerned , to be able to restore that Simulation Object , back from HDF5 file , which is identical to the object used to produce the file. Also, It should be possible to analyse or continue simulation on the restored Simulation Object.</p>
<p>Pallene is a statically typed sister of the Lua programming language. This proposal aims to add support for Closures in Pallene.</p> <p>Closures are functions that are capable of capturing variables from outer scopes and retain references to them even after their scope has been exited. The addition of closures and higher order functions will allow programmers to take a functional approach when authoring libraries and scripts.</p>
<p>TARDIS is a Monte Carlo radiative transfer code whose primary goal is the calculation of theoretical spectra for supernovae based on a number of input parameters, such as the supernova brightness and the abundances of the different chemical elements present in the ejecta. The main idea for this procedure is that by finding a close match between theoretical and observed spectra the parameters that actually describe the supernovae can be identified.</p> <p>The objective of this proposal is to incorporate new atomic data into the TARDIS database. In order to accomplish this job several tasks are required: parsers for different file types must be written, unit testing, full integration with TARDIS codebase and more. Finally, will be crucial to determine how new atomic data affects the synthethic spectra.</p> <p><em>The result of this work will not only be of great value for TARDIS, but also for many researchers who require atomic measurements.</em></p>
<p>The main goal of the project is, which the title says, to port Terra to Android devices. Once I already have Terra ported to android, my intention is to build an interface between Terra and the android API, that way I am sure Terra will support a lot of features common smartphones have as well as be able to use this features in different devices that have Android on it. This way, by the end of the project, we will not only have ported Terra to android but also develop an interface in which developers can easily access hardware sensors and functionalities to build their own applications.</p>
<p>This project aims to provide support for survey methods in StatsModels. In particular, survey summary statistics, adding probability weighting to existing methods such as mixed effect models and Cox models, and inference for complex surveys are primary goals. Additionally, I plan to extend GEE such that the weights are allowed to be non-constant within groups and also implement Weighted Multilevel models. I will write unit tests for all implemented approaches, testing against R and Stata.</p>
<p>The aim of this project is to create a module to import geometric data acquired from terrestrial laser scanners. It will focus on developing a method to directly model real objects and topographies without entering their geometries manually. The information gathered by the laser scanner in the form of ‘Point Cloud Data’ will be used to create a full 3D model of the object. The data from the 3D model is required to be mapped/converted/translated onto the Finite-Difference Time-Domain (FDTD) grid upon which gprMax is based.</p>
<p>DIPY is an open source software mainly focusing on diffusion Magnetic Resonance Imaging (dMRI) analysis. For nonrigid image registration, it implements a Symmetric Normalization framework. The major goal of this framework is to calculate an affine or deffeomorphic transformation to register two 2D images or 3D volumes. As a well-known problem, registration is a non-convex optimization problem. It is very important to initialize as close to the solution as possible. So in order to avoid getting stuck at local optima, it uses a multi-resolution strategy by building a Gaussian Pyramid. That is to say we can register our images in as many stages as we want, providing previous results as initialization for the next. As this way, we need to do a lot of iterations, thus it slow down the optimization process. To speed up the calculation, one solution is to convert to a parallel computing algorithm. The OpenMP API supports multi-platform shared-memory parallel programming in C/C++ and Fortran. So in this project, I will implement a multi-thread algorithm using OpenMP to improve the performance of nonrigid image registration in DIPY.</p>
<h5>The project consists of developing an interface, in Lua, for the set of Cloud IoT Core APIs, through two REST resources:</h5> <ul> <li>cloudiot methods, to facilitate device manager tasks</li> <li>cloudiotdevice methods, to facilitate device communication over the HTTP bridge </li> </ul> <h5>The Proof of Concept</h5> <ul> <li>Another task is to provide a Proof of Concept by using a real world device such as NodeMCU/Raspberry Pi interfaced with temperature sensor to send the temperature data over to the Google Cloud IoT Core. </li> <li>Doing the reverse, sending the data to the device using the Google Cloud IoT Core. We expect this data to be a Code Snippet, which would run dynamically on the device every time it is interrupted by the new code received.</li> </ul> <h5>Development of a software interface with REST support in Lua</h5> <ul> <li>With a minimal GUI this application will make the life of a person using Lua REST APIs easier by providing a simple interface to send and receive data from an endpoint.</li> <li>Testing would be done using the Proof of Concept developed above.</li> </ul>
Modern cloud environments frequently rely on oversubscription to maximize resource utilization, which introduces significant performance challenges for OpenMP applications running inside virtual machines. In such environments, a semantic gap exists between the guest scheduler (which assumes full CPU availability) and the host scheduler (which may preempt virtual CPUs). This project proposes a set of optimizations to the GNU OpenMP runtime (libgomp) that leverage host-side scheduling information to guide execution decisions inside the guest. The core idea is to bridge the host–guest semantic gap using a low-latency shared-memory communication mechanism based \section*{Project Summary}on eBPF and ivshmem, enabling real-time propagation of scheduling metrics without incurring VM-exit overhead. A key component of the project is the implementation of a Phantom Tracker using eBPF, which monitors virtual CPU states on the host and computes a phantom average metric representing scheduling contention. This information is communicated to the guest and used to dynamically adapt two critical aspects of OpenMP execution: the Degree of Parallelism (DoP) and barrier synchronization behavior. To integrate these optimizations, the project extends libgomp with two new environment variables: GOMP_DYNAMIC_POLICY for scheduler-guided parallelism adaptation, and GOMP_WAIT_POLICY for adaptive spin–block synchronization. These enhancements allow OpenMP applications to respond to real-time host conditions, improving performance and resource efficiency under oversubscribed workloads.
The purpose of this project is to extract BTF information for eBPF maps, process it in a human-readable manner, and improve decoding for the bpf() syscall's map manipulation sub-calls.
<p>In the ten years since its creation, the Pharo programming environment has evolved greatly: it now has Github support and many cool tools; it’s faster, better and more convenient to use both for people who have been familiar with Smalltalk for decades and for complete newbies. However, there’s one thing that is behind in improvements -- code completion. And so having already had some experience with it, this is something I want to work on and improve.</p>
<p>Artificial Intelligence and Deep Learning nowadays are ever growing subjects. People who research AI, are experimenting with various intelligence models in order to discover a strong intelligence model which is equally capable with the unknown human model. Prototyping of such models (as large as they may be) needs to be as fast as possible, in order to examine exhaustively many novel ideas as fast as it can be done. For this we need to be able to use with ease as many resources as we have possible. As Theano is contributing to this attempt, current GPU technologies need to be supported extensively in a transient way through its framework. This can be achieved by including optimized operations from current NVidia frameworks, as well as optimizing or designing GPU code which resides in the framework’s backend. Furthermore, analysis and optimization of multi-gpu code, in addition with a consideration of a multi-node/gpu design, would prove themselves useful for this cause.</p>
pocketpy is a lightweight Python interpreter primarily designed for game scripting, boasting a vast feature set encompassing various Python modules. It's competitive performance and elegant syntax have made it a user choice for scientific computations. To enhance its capabilities, this project focuses on adding the core feature set from the NumPy library to pocketpy. There are two primary objectives: 1. Implementing core classes from NumPy: This subtask aims to implement key classes such as ndarray and random, along with their respective methods and functionalities. The code will be written in C++ for performance benefits. Existing C++ libraries like NumCpp (or Xtensor), which offer NumPy-like functionalities, will be leveraged for the implementation. 2. Exposing the C++ implementation to Python through bindings: To achieve this goal, we will use a library named pybind11, a popular header only library used to generate bindings for C++ classes automatically. This step will allow users to work on a pythonic frontend and access the NumPy functionalities implemented in C++. By the end of this summer, pocketpy seeks to offer robust array operations and random number generation capabilities, positioning it as a versatile tool for various computational tasks beyond game scripting.
d-SEAMS currently uses an embedded Lua interpreter to provide user interactivity in tandem with YAML inputs for selecting workflows. The project seeks to replace this interface with a Python interface. This is expected to take place in two stages: - Replacing the Lua Interpreter with Python - Binding to C++ classes and functions directly With both of these milestones completed, feature parity will be kept with the existing code while also providing much more flexibility due to the Python library formed in the second deliverable.
I will migrate the eos-icons.com website to TypeScript and Next.js and also implement proper file management and state management in the project ensuring a cleaner and more scalable codebase. I will also do certain changes to improve the website's UI. I plan to add a navigable menu to the landing page showing all categories of the icons. Also, adding a new and improved HowTo section which contains information about the usage of icons in all places like React, Vue2/3, & HTML, and moving it into a side drawer panel along with the icon editor. I plan to add unit tests by using Jest & React-testing-library, and end-to-end(e2e) testing with Cypress.js. I will integrate these tests with Github CI/CD pipelines and ensure proper development workflow using es-lint, prettier and husky.
<p>I will introduce methods to pgmpy to select Bayesian models based on data sets. First, I will implement support for basic score-based and constraint-based structure learning. Second, I will add common enhancements to the score-based approach, including local score computation + memoization and tabu lists. Finally, I will implement the MMHC algorithm, which combines the score-based and the constraint-based method.</p> <p>I believe that structure learning is <em>the</em> missing feature in pgmpy at the moment.</p>
<p>The project is a demo for the Hydra draft proposed by the W3C. It aims to build a smart client and server that is able to exchange information in an efficient manner over a RESTful API using a Hydra based vocabulary. A smart client is able to communicate with the server even without previously knowing the supported methods of the server. This is made possible using Hydra's API documentation method. Hydra is a push towards the idea of semantic web and it's potential as a mean of communication is demonstrated in this project. This project lays the foundation for a larger project that showcases Hydra's full potential.</p>
<p>The aim of this project is to create a lot of packages, so that it will be way easier to maintain bears, and to update them with awesome features. This will also include easier debugging as we will only have to focus on one bear at a time.</p>
<p>I have started doing the initial work on the EOS Adobe XD plugin and I found the community extremely supportive. For the summer, my goal would be to increase the capabilities of the Adobe XD plugin, and develop the Angular package for EOS. This might touch the sister packages for React library and the original NPM package and I would ensure there are no frictions during development and we are on the same page while moving forward.</p>
Eye-tracking devices are widely used in neuroscience research. Studies of visual perception and attention in particular are increasingly integrating eye-tracking and EEG/MEG devices, in order to gain a better understanding of these processes and their neural correlates. However, the Python community has yet to coalesce around a well-supported package for analyzing eye-tracking signals. This project proposes to integrate support for reading, visualizing, and analyzing eye-tracking signals in MNE-Python. By incorporating the ability to analyze eye-tracking data into MNE-Python, researchers would be able to analyze both neural and eye movement data within the same software environment, making MNE-Python more versatile and useful for a wider range of research questions. Finally, MNE-Python has a large community of developers and users, making it likely that eye-tracking integration will prove useful for many in the scientific Python community. This project will focus on building a robust I/O routine for eye-tracking data and developing functions for preprocessing, visualization, and analytical routines that are commonly required in eye-tracking research. This includes the ability to interpolate eye-position data during blinks, produce heatmap plots of eye-position across trials, and estimate the deconvolved pupil response.
<p>The main objective of this project is to create such interfaces (by the means of various visualizations of the library) that makes it easier for user to:</p> <ul> <li>Access the required filter curves</li> <li>Calculate the photometry of a star's spectrum under a certain filter set</li> </ul> <p>To achieve this, I propose to develop several adequate visualizations by enabling interactivity and UI controls, such that they serve as <strong>analytical web interfaces</strong> through which user can access what they need in a couple of clicks! These interfaces will be made accessible to the user by integrating them within living Sphinx docs, such that they will be auto generated when building the docs.</p> <p>Besides, I also aim to well document the wsynphot package after integrating the developed interfaces in it, ultimately reshaping the entire package. Hence, user can <em>auto-generate both the filter curves & photometry</em> directly from the docs as per their requirements, by using these responsive interfaces.</p>
Borg stores each deduplicated chunk as a separate file. On SFTP, that's one network round-trip per chunk. Pack files bundle N chunks into one file. A TOC sits in the trailer, and the pack gets a SHA256 derived pack_id. The client caches a small index per pack locally. Borg compact handles cleanup by mark-and-sweep to find dead chunks, then rewrite sparse packs into dense ones. Deliverables: pack file write and read support in borg2, borg compact with pack rewriting, incremental per-pack index cache, and encrypted pack support.