Explore Projects

<p>QEMU's TCG just-in-time compiler translates target CPU instructions into host CPU instructions so that programs written for other CPU architectures can be run on any host. Modern CPUs feature vector processing instructions, sometimes called Single Instruction Multiple Data (SIMD) instructions, which perform the same operation on multiple data elements at once. Intel's SSE and AVX instruction set extensions were introduced for x86 CPUs for this purpose.</p> <p>The target/i386 front-end has support for TCG emulation of SSE4.2, but does not feature support for later vector extensions, such as AVX. The goal of the proposed project is to implement and test AVX instructions that are currently not implemented in QEMU's TCG.</p>

Macro is a metaprogramming feature that allows programmers to analyze and synthesize code at compile-time. Scala 3 supports a powerful yet type-safe macro system that allows analysis of the structure of code fragments via quote pattern matching. In this project, we aim for two goals: 1. The current implementation of quote pattern matching does not have many tests and is expected to be unstable. I propose making the feature more reliable by creating a checklist that captures which language features should be supported and adding more automated tests based on the checklist. 2. The current quote pattern matching does not support extraction of polymorphic functions. I propose extending HOAS patterns to support pattern matching against polymorphic functions based on formal definitions.

Investigate and implement alternative font renderers in FreeType, including: • font-rs: A font renderer developed by Raph Levien. A blogpost describes some of its features in more detail. It claims to be much faster than FreeType's anti-aliasing rendering module by using different data structures, SIMD optimizations etc. • font-go: Port of font-rs to the Go programming language, includes a fixed-point implementation that is allegedly 1.4 times faster. • fontdue: It is another rendering engine based on font-rs, and it claims to be even faster and is actively developed. Additional discussion can be found here. • Pathfinder: Another project inspired by font-rs is Pathfinder, which takes advantages of GPU rendering. The project involves continuing and eventually finalizing the GSoC 2022 contribution, including but not limited to improving build system support, adding SIMD optimizations to more processors, improving documentation etc

<p>Very often, the QEMU emulator is used to emulate user level processes that are compiled for a different architecture set than the "host" machine on which they are running. This operating mode in QEMU is called the user mode and it is much simpler than the more commonly known system mode in which the full computer system is emulated. The user mode is useful for fast cross execution and debugging and is usually executed on Linux based systems. It achieves this cross execution by having its' own implementations of system functions from the Linux kernel interface. Although many system functions are supported in QEMU, the kernel is constantly extended by addition of new system calls. QEMU user mode can't consistently follow this kernel extension and thus many kernel functions are left unimplemented. The goal of this project is to significantly extend this QEMUs implementation of system functions so that many user programs that depend on these system calls can be safely cross executed. This projects' contribution also extends to the Linux Test Project by developing unit tests for system functions implemented within QEMU.</p>

<p>The Apache Gora™ an in-memory data model and persistence for big data. Gora provides a generic API to work with different datastores. Data storing, data persisting and querying can be done via Gora APIs on these data stores. Apart from data stores gora provides support for mapReduce, Apache Spark, Apache Pig and Apache Flink. On the other hand, Hazelcast jet is an emerging distributed computing engine which competes shoulder to shoulder with Apache spark and others. So this project is to add Hazelcast Jet execution engine support for Apache Gora.</p>

<p>The project will implement the following features:</p> <p><strong>Extended language support for container Engine</strong>: The current version of container engine can handle only PHP based challenges. With this project the container engine will be extending support to add challenges based on:</p> <ul> <li>Node.js</li> <li>Ruby on Rails</li> </ul> <p><strong>OWASP Top 10 challenges on other platforms</strong>: After adding the support for Node.js and Ruby on Rails, new challenges will be added to container engine which covers OWASP top 10 attacks on both scripting languages along with PHP.</p> <p><strong>Extending the ability to upload custom containers</strong>: The ability to upload custom containers to hackademic by challenge authors will be introduced to hackademic so that authors can have a flexible solution to create awesome challenges.</p>

I propose to augment the current project by implementing pending pipeline features which will drastically improve the security and capability of the base application. Specifically I propose implementing secure RSA encryption to the messaging service, implement secure file sharing with audio and video support and enable user discovery on a WiFi network using UIDs RSA encryption I propose using the rsa_encrypt library in dart to secure the chat service being created between two clients on the same peer network. When two clients are connected on the same peer network, a connection is created using FPTP protocol. This project proposes to use rsa_encrypt to create a security layer over the FPTP layer. Hence the chat service is secure from other possible listeners on the peer network. Secure file sharing I propose to extend the messaging service with file sharing capabilities. We transcribe the file stored in the client’s local storage into raw metadata and securely stream the bytes to the connected client using the RSA encryption layer. The client checks for the file type using MIMETypes and decodes the bytes into the intended file. This implementation is expected to use the dart:convert library for encoding and decoding. The challenge which I aim to surpass is encoding the raw bytes through the RSA layer to ensure that unauthorized listeners cannot access the raw bytes. File Viewing I propose to implement in app file previews for supported file types using open-file-x and also enable in app viewing for image and video file types. User Discovery on a Local Network The challenge here would be for the application to persist UIDs which can be advertised over the WiFi network. Flutter does not have the capability to access users connected to a WiFi network unless the application is the router. Hence I propose to use mDNS to allow the devices to broadcast their presence on the same network without needing a central server.

Implement message mediator service written in Rust with pick-up v2 protocol support on top of aries-vcx crate. Learning Objectives - Learn about self sovereign identity and Aries protocols - Learn about writing scalable server applications - Learn Rust language - Learn Github Actions and CI process in general Expected Outcome - Web service for Aries message mediation - CI jobs to test the implementation

Umbra has been developed in the past 2 years thanks to successful internship projects, its final target is the development of a platform for emulating blockchain projects and conducting academic research. This year the goal of the internship project is to unleash the full potential of Umbra, therefore running large scale tests added to chaos engineering mechanisms. The intern is going to work on mechanism that enable chaos engineering in Umbra, execute large scale tests in cloud providers (thousands of nodes), and present measurement reports of blockchain and infrastructure metrics. The goal is to enhance Umbra to a stable release, prove its full potential, and produce material to be reproducible by different academic institutions teach and perform research with the developed Umbra experiments. Expected Outcome Enhance Umbra source code, enable a stable experimentation environment for Umbra in cloud environments with large topologies (e.g., thousands of nodes), generate chaos engineering mechanisms in Umbra, capture the events in dashboards, and generate comprehensive reports detailing an Umbra experiment.

Currently, Casbin uses golang built-in map structure to maintain policies in the main memory and persist the policies via adapter abstraction. If policies data grows, however, the growing cost of main memory resources and bad performance make the memory management strategy not tolerable anymore. We need to find a better way to manage the casbin in-memory data when data grows. From my point of view, our main goal is to reduce the cost of memory as well as keep good performance handling policies read and write requests. In order to achieve those key goals, we can introduce an experimental tuple storage to get charge of storing those policies, turning the policies management strategy from memory-oriented to disk-oriented. We can even make a better abstraction of the storage layer so that we can use different engines (row, column) for the different workloads. In general, we can take the following parts into consideration to achieve our goals. 1. API for upper layer. 2. workload optimizer. 3. Buffer Pool management. 4. Indexing. 5. Data Storage Structures. 6. Transaction if necessary. And in the end, the deliverables will be : A Casbin built-in embedded disk-oriented tuple storage engine. The Engine should contain ： 1. Carefully designed API for upper Casbin internal module. 2. Storage management. Include file organization and page layout. 3. Buffer pool management. 4. Index management. 5. An workload optimizer for the upper layer. 6. Transaction part if necessary.

We have added solid foundation for query observability in the new engine during the previous LFX mentorship term. Let's continue the awesome work by Pradyumna by implementing other features. - Expected outcome: other query observability visualizations are implemented; extra observability data has been added

UIMA is a framework for unstructured information management, in production use for about two decades. The framework is available in C++ and Java, where the C++ version implements a subset of the features of the Java version. This project aims to implement the full framework in C++ through adding support for aggregate engines by mirroring that of the Java implementation.

<p>The streams based workflow engine will organize tasks into streams, allow parallelization of this streams, and work locally as well as integrated into common external HPC services. As well dat can be integrated to store intermediate and final data. This provides a framework for efficient, reproducible, and understandable bioinformatics pipelines.</p>

<p>I propose to implement Trains Emission for Carbon Footprint Extension, currently, it is implemented only for 5 sources(of France), I intend to implement it for India, UK,USA, Australlia, European countries (including norway, germany, italy, sweden, greece), Canada. I also intend to improve the error detection system of extension and start integrating bus services on sites like kayak.</p>

<p>My primary targets for the summer are as follows:</p> <ul> <li>Solve issues across Zulip's message rendering pipeline.</li> <li>Assist in converting the Zulip webapp frontend codebase to typescript.</li> <li>Develop experimental features.</li> <li>Try to make Zulip's markdown easier to use.</li> </ul> <p>I've covered the above four points in detail inside my proposal.</p>

GIMPs typographic engine is currently limited by legacy GTK3 and Pango constraints. This project overhauls the text backend by directly integrating HarfBuzz to extract font data and advancing GIMPs experimental text layout library. Deliverables include migrating the font chooser to modern GTK list models, grouping fonts by WWS families, and introducing modular on canvas UI controls for variable font axes and OpenType features.

This proposal provides a detailed overview of the development of an LLM-based conversational assistant with domain-specific knowledge about the OpenROAD project. The primary focus is on data engineering and testing to enhance the model’s capabilities. The assistant is designed to improve user interaction by providing accurate responses to queries regarding OpenROAD’s tools and features. We will be leveraging Fine-Tuning and Retrieval-Augmented Generation (RAG) architecture and we will address key LLM challenges.

<h3>Visualisation of the MOLTO-3BP Incorporating Matlab Python SDK</h3> <p>I am aware there are many applicants, thus I sincerely apologize and regret my delay but hope I can be given an assignment/evaluation test.</p> <p>I'm applying to the track for the visualisation of the MOLTO-3BP network as I am enrolled to start a graduate program in CS using distributed technology and am interested in the applications of orbital equations and computing problems.</p> <p>My motivation lies in my current interest for Backend and Frontend applications as I also work with a company managing their ML algorithms for data prediction in arbitrage contexts as lead analyst and developer for the Full-stack infrastructure to support such volume and structure the visualisation process for qualitative information (as quantitative is given by volume in this case). I am now interested in leveraging such skillset to perhaps a more researching-focused world in lieu of an economic speculative industrial motivator.</p> <p>I believe the 3BP is very interesting from a theoretical point of view and can be greatly improved with visual filter and newer GUI revamp to its already robust computational engine (orbital eq in the halo numerical model)</p>

Text-to-speech is a critical accessibility feature that is currently not present in many ScummVM engines. Adding text-to-speech to more engines can assist language learners and those with visual impairments, as well as standardize implementation of text-to-speech across engines. In this project, text-to-speech is implemented on an engine-by-engine basis by defining GUI options for text-to-speech; identifying procedures that display text, which may include objects, menus, dialogue, and other forms of text; cleaning up the text, if necessary; and feeding this text into text-to-speech. It aims to include full text-to-speech support for a variety of engines.

<p>A crucial component of the user experience with bots in Rocket chat android app is rich messages. Currently, there is only minimal support for rich messages in the Android app with the only support for Horizontal Buttons, Multiple Buttons, Image Buttons with URL and Buttons with URL.</p> <h4>I propose to enhance the user experience with bots by implementing other rich messages types, interactive rich messages, welcome screen for bots into the existing Rocket chat Android Client.</h4> <p>The goal is to improve user experience with bots by:</p> <ul> <li>Adding Webview support to the existing Rich message types.</li> <li>Adding support to the deferred rich message types like temporary text buttons, and other types which requires editing of the message.</li> <li>Implementing other Rich messages types like section with menus, overflows, buttons, Date pickers, Articles.</li> <li>Adding interactivity to the rich messages to increase usability with bots.</li> <li>Implementing a welcome screen for bots similar to facebook.</li> <li>Writing unit tests and espresso tests for UI level testing</li> <li>Implementing a bot with all the new features.</li> <li>Solving random crashes and left issues and improving documentation.</li> </ul>

<h3>Implementation of Newsfeed (a social feature) in Rocket.Chat Server</h3> <p>This project adds a newsfeed for every user. In it, the users can follow other users. Whenever a user posts something in a public channel or does any public activity, it would appear in the newsfeed of all his followers with a link to the original post in the original channel. This would greatly help in discovering new conversations, increasing accountability of people in the organisation &amp; increasing many folds the time a user spends on RC</p> <p><strong>The most challenging part of creating the newsfeed is to make it scalable to support a large number of concurrent users (by using an adaptive follower/following relation model) and to benchmark the server performance in relaying the correct messages with filters. This is being done by using proper schema and proper database queries. Messages in newsfeed are fetched in real-time from messages stored for other channels.</strong></p> <p><em>Key Features:</em></p> <ul> <li>Support for Rich Message blocks</li> <li>Auto-summarization of messages to prevent spam in newsfeed</li> <li>Expandable embedded conversations</li> <li>Upvoting System &amp; Trending messages</li> <li>Group messages by origin user, date, channel etc.</li> <li>Integration with other projects</li> </ul>

<p>Dialyzer is a discrepancy analyzer that ships as part of the Erlang VM. There are two projects that adds Dialyzer support to Elixir applications: dialyxir and dialyzex. The goal of this project is to bring the ideas of both projects with two main new features: better usability (in particular, better error messages and formatting) and the ability to dialyze projects incrementally.</p>

This project's goal is to enhance the usability and accessibility of GNU Aris. It addresses the issues that students currently struggle with when using Aris and implements their requested features: - Detailed and helpful error messages - Full internationalization (i18n) support. - An exclusive disjunction operator and an option to use the the rule of inference for a proof by contrapositive. - UI/UX enhancements: Zoom functionality, an in-application help/documentation, syntax highlighting, etc.