Explore Projects

<p>Riak KV is an open source database with a strong focus on low latency, reliability and fault tolerance. Like any well tested computer system, batteries of tests are run to make sure that the database behaves correctly in typical but also adverse conditions such as network partitions, or even the deployment and upgrade process of nodes running different versions in the same cluster. To this end, one of the resources used by the Riak team is <a href="https://github.com/basho/riak_test" target="_blank">riak_test</a>. Its main function is to provide a test running framework that overlaps significantly with Common Test, but it also contains cluster management and code intercept functionalities. We propose to break up this repository into its discrete components, making important contributions to the Erlang community and adapting the test runner framework into Common Test suites, vastly increasing the reporting ability of current Riak tests.</p>

Many bug reports from almost 10 years ago to even recent times report that GNU Lilypond has been unable to correctly render note subdivision beams and tuple subdivisions, more evidently in some cases of complex rhythm and meter. After comprehensive assessment and analysis of these issues by the developers, the developers have determined that the current code responsible for those capabilities should be rewritten and refactored. The reason that note subdivision and beaming can be difficult to implement is that music theory heavily relies on powers of 2 and their reciprocals. It's very convenient to composers, instrument players and developers too. That convenience doesn't address the problems rhythmic complexity can pose. Concepts such as compound time signatures, tuplets (group of notes that are not bounded by the powers of 2) and manually setting relevant Lilypond attributes. My project proposes a new way of representing the concept of music theory beams and groupings with different object attributes. My project proposes to fix this Lilypond issue by rewriting `lily/beaming-pattern.cc` (the C++ source file mostly responsible for this issue's logic) and fixing/refactoring relevant C++/Scheme source files. I plan to first refactor such source files to fix regular note automatic subdivision and beaming, then fix tuplet subdivision in later weeks. Heavy code modifications will include updating documentation, adding regression tests, and formatting Lilypond's `convert-ly` rules corresponding to the above two issues. Once the issue of beaming subdivisions is fixed, developers and even anyone wishing to compose rhythmically-complex scores should not have to worry about this obstacle.

<p>The project idea aims at developing a plugin (as GNU Social is true to the Unix-philosophy of small programs to do a small job) that will implement the ActivityPub Protocol in GNU Social.</p> <p>GNU Social is a social communication software used in federated social networks. In a federated social network, user data stays in the user's server instead of a centralized one.</p> <p>In order to achieve said decentralization, a variety of standards on how communication between different pieces of software in a federated context should be done were created, such as OStatus. ActivityPub, however, is the newest and covers parts left out of OStatus's specification, namely the app/client development.</p> <p>Because of this and given that newer software will focus on the implementation of the ActivityPub Protocol, GNU Social is looking forward to supporting it in order to stay updated and relevant in an even larger fediverse.</p>

There are many secondary goals for this project, but the main goal is to make the fuselage compatible with React Native. But also, we have figthing against the bundle size of the fuselage, and of course performance which is always a concern. Using the tamagui as a base, we can components that are compatible with both platforms, and in a efficient way.

This project aims to develop an automated system that simplifies the packaging of freeware games for various platforms (like google play, steam, etc.). This system includes predefined platform-specific rules to generate game packages. The resulting distributable is ready for uploading to different platforms, including Linux, Google Play, Apple App Store, Steam, and ForgeTV store. Users can then browse and download these game packages using the proposed ScummVM downloader GUI. Moreover, the system also includes a bundler script that bundles the game with ScummVM to create a standalone application for distribution.

<p>The Rocket.Chat team for iOS has been working on improving the UI, and is planning to come out with a major app re-design for version 2.3.0. One of their goals to support this redesign is to add the ability to theme the application.</p> <p>My project for the summer will focus on theming the application whilst introducing a minimal amount of impact on the rest of the code base.</p>

<p>Liberty Eiffel language available on windows environment.</p>

<p>This Project aims to make Command Palette for Godot game engine that can execute some major editor actions available in editor menus. this project helps in increasing users productivity through keyboard and helps in memorizing shortcuts.</p>

<p>Thinking everyone got a message, but for some it didn't arrive – that is bad. This project will improve Matrix to better handle cases in which bridges couldn't deliver what they were asked for. It does so by adding new failure modes for bridges which can inform the user that something just isn't quite right.</p>

<p>While making medium to large scale games in Godot, many small bugs start to creep in that cannot be caught by the compiler. These can only be dealt with manually while debugging. This project will build a tool to be used semi-regularly to highlight these problematic pieces of code in an automated fashion. This essentially extends the scope of static checks , currently just being within each script, to operate across scripts and scenes.</p>

<p>Adding a Version Control API to Godot which supports working with multiple types of popular VCSs (both distributed and central). This API shall be used to implement multiple VCS friendly features to the Godot Editor. The VCS API will be supporting multiple popular VCSs (like Git, SVN, Mercurial, and Perforce).</p> <p>Since Godot is gradually entering the competitive market, dominated by Unreal Engine and Unity3D, it is only intuitive that it should support Godot game developers with a strong version control integration from within the editor.</p>

<p>Visual Scripting Language is a part of Godot Engine that is fairly underdeveloped. But it still is a really powerful system which just needs to be properly improved for it to reach maturity.</p> <p>The idea is to add UI and UX changes to Visual Script Language that make it much <strong>less intimidating</strong> and allows for a much <strong>friendlier interface</strong> and has a <strong>Simplified API</strong> rather than being a GDScript with Nodes kind of a setup.</p> <p>Some ideas for improvement would be unifying the scripting graph, improve node quality and UI/UX changes to support the new features. Further, plans would be to ensure less breaking issues/bugs, and improving overall usability.</p> <p>An extended goal would be to work on the Group Nodes(VisualScript based CustomNodes) to allow for increased and simplified modularity.</p>

Currently, keeping privacy in mind, Matrix uses seshat to store a searchable database on the user’s device itself. As the number of conversations and messages increase, maintaining an index on the client side becomes tougher. The solution to these problems is a Searchable Symmetric Encryption (SSE) scheme that lets the client safely store an encrypted database on an untrusted server and search through it with full privacy. This project will implement, in particular, the keyword search scheme outlined in a Demertzis et al. paper titled “Fast Searchable Encryption with Tunable Locality”. I will achieve this by creating a Python library that exposes methods to create, update and search on encrypted indices stored in content repositories in a Matrix homeserver. As a part of the project I will be demonstratively integrating the library into an existing Matrix client. Additionally, I will submit results of preliminary performance evaluation.

MedEye3D.jl aims to enhance medical imaging visualization within the Julia language ecosystem. The current proposal addresses the need for improved functionality in windowing, support for the display of super voxels, faster load times, and robust viewing of multiple images. By leveraging Rocket.jl and ModernGL.jl, the proposal plans to implement features like enhanced windowing for MRI and PET data, support for the display of super voxels, and high-level functions for improved user experience. The project aims to streamline visualization processes and provide essential tools for 3D medical imaging workflows. The main deliverables include: Supporting simultaneous visualization of multiple registered medical images, with linked scrolling, cursor highlighting, and connecting lines between annotated points across images. Implementing automatic windowing and colormaps for common MRI and PET imaging modalities to provide consistent visualizations mimicking other medical imaging software. Adding support for visualizing supervoxel segmentations with boundary detection using techniques like the Sobel filter. Improving startup time by precompiling critical components of the package. Implementing high-level functions to simplify basic usage by abstracting away low-level details of image loading, rendering, and visualization. By enhancing MedEye3D.jl with these features, the project aims to provide a more comprehensive and user-friendly tool for 3D medical image visualization and analysis within the Julia ecosystem. The improvements will facilitate better integration into medical imaging workflows and enable more efficient exploration and interpretation of data across different modalities.

<p>I would like to extend and update Turing’s documentation and include novel examples that show how to best use Turing’s capabilities in an applied setting.</p>

Molly.jl is a package in pure Julia for simulating molecules and physical systems in general using method known as Molecular Dynamics (MD). This project implemented a class of molecular dynamics simulations known as replica exchange molecular dynamics (REMD) to this library. REMD methods are very important in the study of complex biomolecules such as proteins, due to their ability to better explore the configurational space of such molecular systems by running many parallel copies of MD simulations with different conditions and sampling states from all these copies. These states are then periodically exchanged which helps in evading local minima. During the complete project phase, variants of REMD known as temperature-REMD and Hamiltonian-REMD were implemented. Along with these a general interface to define custom REMD simulations, improvements to the parallelization, more potentials and many improvements to the whole library in general were introduced.

<p>Documentation, essential for any software project, needs to be as easy as possible to write and publish. For Julia packages, you can use the <a href="https://github.com/JuliaDocs/Documenter.jl" target="_blank">Documenter package</a>, which automatically generates and publishes package manuals as a web page or a PDF.</p> <p>It is important for Documenter to be modern and flexible. This project aims to revitalize Documenter, by upgrading the generated HTML front end and making it easier for documentation authors to customize. This will make sure that Documenter will keep meeting the needs of the community for years to come.</p>

Traditionally if a user asks a question to an LLM about a package then, the response might be incorrect, or outdated. The project "Supercharging the Knowledge Base of AIHelpMe.jl" is about extending AIHelpMe’s knowledge base and build a RAG system to include the latest information about its documentation and to increase the accuracy of LLM’s response. Incorporating comprehensive, up-to-date Julia’s resources into the AI’s knowledge base will benefit Julia developers, programmers, AI and ML enthusiasts, or any programmer to get more accurate responses, clear doubts and solve bugs.

<p>Agent-based models (ABMs) are simulations in which autonomous entities (known as agents) react to their environment (which includes other agents) based on a predefined set of rules. The objective is to analyze the effect of agent behavior on the model as a whole. Agents.jl is a pure Julia library that assists with the creation of performant ABMs. It provides various tools and utilities to simulate complex agent-model behavior with little effort. My proposal is to add the following two features that are currently not present in Agents.jl:</p> <ol> <li>Serialization and deserialization of model state</li> <li>Extending pathfinding functionality<ul> <li>Pathfinding in continuous space</li> <li>Low-level control over the pathfinding API</li> </ul> </li> </ol>

This project is aimed at advancing the capabilities of heterogeneous computing environments in Julia through Dagger.jl. We propose to implement a series of enhancements for significantly improving task execution efficiency, data transfer speed and robustness of distributed parallel computing systems. We place special emphasis on further development of streaming data processing for distributed heterogeneous systems with Dagger.jl. Heterogeneous computing environments leverage a combination of resources - such as CPUs, GPUs, DPUs - and face challenges in optimizing task execution and data streaming. Data transfer mechanisms are often inefficient or may lack robustness against system slowdowns or failures. The project will be supporting ongoing radio astronomy and ionospheric RADAR work at MIT and its Haystack Observatory — bringing about real-world impact in the short-term.

The David-Skene algorithms are a family of computational methods for aggregating crowdsourced annotations of data in order to obtain the true labels or categories for that data, which is very useful in places where we do not have access to the "true" annotations for large datasets and therefore need to rely on fallible human judgment. The most traditional version of the David-Skene (DS) algorithm dates back to 1979 but more recently a more efficient (eightfold sppedup) although less accurate version, called Fast David-Skene (FDS) has been developed. The hybrid variant (HDS) sits in the middle in terms of accuracy and speed between DS and FDS. Since demands for the two differ according to situation, it makes sense to implement all thre versions (DS, FDS, and HDS) so that everyone interested can use the one most suitable to their situation. This is the purspose of this project. Additionally, the algorithms in question will be extended to be applied to multi-label problems as well.

QuantumClifford.jl enables efficient simulation of Clifford circuits acting on stabilizer states using the (de)stabilizer formalism, with complexity O(𝑛²), where 𝑛 is the number of qubits. For sparse stabilizer states—those with a qubit connectivity of O(log 𝑛)—an alternative algorithm based on graph states achieves improved complexity of O(𝑛 log 𝑛). This project aims to implement this graph-states-based simulator as an alternative backend in `QuantumClifford.jl`. Specifically, the project will: support the simulation of generator gates {𝐻, 𝑆, Λ𝑍}, enable the decomposition of arbitrary Clifford gates into these three generators, and implement single-qubit Pauli measurements on graph states. The goal is to provide a seamless transition to the graph-based simulator through compatibility with existing `apply!` and `project!` APIs in `QuantumClifford.jl`.

KomaMRI.jl is a Julia package for Magnetic Resonance Imaging (MRI) simulation focused on speed and extensibility. Like other MRI simulators, it solves the Bloch equations, for which the solution can be parallelized due to the independent spin property of the system. Although KomaMRI currently has built-in support for GPU and CPU parallelization, GPU support is CUDA-based and could be extended to work with different GPU backends. In addition, writing GPU kernels tailored for the solution implementation could significantly improve performance compared with the current array-based approach. The goals for this project are to update the KomaMRI.jl package to support Metal, AMD, and OneAPI-based GPU backends, and create a new BlochKernel simulation method which is fully kernel-based and optimized. If time permits, the use of MPI.jl and Distributed.jl to run MRI simulations across multiple nodes and GPUs will also be explored.