Explore Projects

This proposal aims to solve the issue of using high-order functions with asynchronous functions when there is no platform support of continuations and without implementation of two variants of HOFs (synchronous and asynchronous). The plan is to add basic functionality of auto generation of CPS transformed HOFs in the dotty-cps-async compiler plugin.

<p>Semantic information is essential for rich IDE features such as <code>go-to-implementation</code> and <code>rename</code>. Metals utilizes semantic information extracted from the compiler in a SemanticDB data model form to realize several features. However, SemanticDB generated from Scala3 lacks some kinds of information: Signature and Synthetic. Therefore some IDE features are not available in Scala3 projects.</p> <p>The objective of this project is to improve the SemanticDB extractor for Scala3, and pave the way to better Scala3 support in Metals, scalafix, and other dev tools relying on SemanticDB.</p>

This proposal aims to develop a sampler instrument for the Sounds of Scala project. Sounds of Scala is a web audio and music library that runs on the Web Audio API via Scala.js. The sampler will be a digital music instrument with features including sample loading, playback controls, looping, and sample manipulation, along with advanced functionalities such as adjusting playback speed, pitch, and direction. Its applications range from music composition to educational purposes. This project seeks to expand the creative possibilities of the Sounds of Scala library, providing a valuable tool for music enthusiasts, developers, educators, and artists.

LLM4S is building a Scala-native AI toolkit that leverages functional programming principles and strict compile-time checks to ensure the reliability and maintainability of LLM-powered applications. This project aims to extend the initial agentic loop and implement essential tools, empowering Scala developers to build robust, reliable, and explainable AI solutions. Key objectives include implementing a robust agentic loop, integrating MCP for dynamic tool interaction, developing core tools for file systems, ensuring context management, testing frameworks, and comprehensive documentation to support reliable LLM-powered applications.

This project aims to bring the power of Retrieval-Augmented Generation (RAG) into the Scala ecosystem by building a robust Scala interface to interact with RAG pipelines. I will design a Scala-compatible wrapper to connect with Python-based components like FAISS and Hugging Face Transformers via gRPC or HTTP APIs. The project will also include developing idiomatic Scala modules for preprocessing, querying, and evaluating textual data, making it easier for Scala developers to integrate RAG into NLP or search applications. By providing seamless interoperability and modular architecture, this will empower the Scala community to build intelligent, language-aware systems more efficiently.

This project will add bitmap convolution support to Doodle, enabling powerful image processing effects like blurring, sharpening, edge detection, and embossing. The implementation will design a clean functional API for convolutions that works across Doodle's backends (Java2D and SVG), despite their different underlying implementations. For Java2D, the solution will render elements to bitmap buffers before applying convolutions, while for SVG, it will leverage native filter capabilities. The project will include standard convolution kernels, composition operations, comprehensive documentation, and examples. This enhancement will significantly expand Doodle's capabilities beyond vector graphics while maintaining its functional programming model.

This project aims to develop a prototype that simplifies data exchange within Slack, enabling seamless information retrieval and input with minimal effort. The primary focus is on creating an intuitive, efficient interface to streamline workflows and enhance productivity. Additionally, the project involves researching the feasibility of extending support to other communication platforms (e.g., Microsoft Teams, Discord) by analyzing API complexities, authentication mechanisms, and integration challenges. The outcome will include a functional Slack prototype alongside a comparative assessment of cross-platform compatibility, identifying key barriers and potential solutions for future expansion. This work will contribute to a more interconnected and automated workspace ecosystem, reducing manual effort in information management.

<p>The project aims to improve the integration between <code>ScalaPy</code> and <code>Ammonite</code>/<code>Almond</code> by providing a frictionless installation experience plus a number of quality of life features such as code completion and displaying rich presentations of Python objects. The project also involves developing a Scala - Python integrated environment in which users can switch between a Scala and Python shell and exchange variables between them. The project could benefit Scala programmers seeking access to Python libraries, typically data science and deep learning frameworks, by providing them with a smoother user experience. In addition, it could also help Scala attract Python programmers, who are looking for a type safe language with better concurrency and parallelism support.</p>

Currently, dotty-cps-async does not support effect systems, hindering its further development. Additionally, there is no mechanism to automatically convert existing standard monads to effect system monads, resulting in increased boilerplate code. To address these issues, a macro will be used to assemble code-based effects to CpsMonad. Additionally, automatic conversion of existing monads to effect system monads will be developed using additional monad converters that will be implicitly applied. The outcome will be the ability to use effect system monads through the async[[X] =>> Monad[R, X]] syntax, facilitating easy composition of various effect systems. Furthermore, automatic conversion of existing standard monads such as Option, Either, List, etc., to effect system monads will streamline and enhance the user experience, reducing boilerplate code.

The current state of the asynchronous I/O on the JVM involves using separate selector threads to manage I/O events through system functions like epoll or kqueue. Although frameworks like Netty and NIO2 make this approach seem reasonable, the use of separate event loop threads is not without cost. In high-RPS services, these threads can compete for CPU time with worker threads executing application tasks, leading to resource contention and potentially significant performance loss. In contrast, Cats Effect offers a different threading model, integrating I/O and application tasks into a single runtime system, reducing contention an enhancing overall efficiency. io_uring, the key component of this project, offers two major advantages: (1) it enables all supported syscalls to become asynchronous from the application’s perspective, allowing for multiple syscalls to be initiated in parallel without blocking the calling thread, and (2) it uses a pair of ring buffers for syscall submission and completion events that are shared between the application and the kernel, dramatically reducing the overhead of calling from userspace into kernelspace. When integrated with Cats Effect, io_uring can significantly improve the efficiency of syscalls, requiring fewer calls into kernelspace during the worker loop. This proposal brings two key innovations together: a new threading model and a new I/O API. By integrating Cats Effects and FS2 with io_uring, we aim to develop an alternative solution to minimize the inefficiencies found in the traditional model, offering a more efficient and performant solution for I/O-intensive applications.

<p>Dendrite is a matrix server built in GO.<br> It's known that our state of the art Synapse is reaching it's limits in terms of performance.<br> Dendrite is an effort to provide fast, scalable and efficient alternative.<br> Although very promising, dendrite has a long way to go before it's ready to handle matrix's rooms.<br> This project is an effort to push dendrite towards feature completion.</p> <h4>Goals</h4> <p>Go over the current state of federation in dendrite and fill in the missing APIs.<br> Improve the reliability and stability of several components, while freeing them of known issues.<br> Add commonly used but missing functionalities.</p>

CrashDragon plays a critical role in transforming VLC crash reports into actionable fixes, but current gaps in API consistency, auth-sensitive behavior, and frontend completeness introduce friction in triage and integration workflows. This project is a continuation of prior work and focuses on improving reliability without breaking existing functionality. The approach includes: Reviewing current API and frontend behavior to identify inconsistencies between public routes and /api/v1. Improving the Go backend by standardizing API response contracts, tightening validation, and hardening auth-sensitive mutation paths while preserving backward compatibility. Completing missing frontend surfaces and aligning Vue service-layer logic with typed API contracts to eliminate fragile response handling. The project will be delivered through incremental, review-driven changes with strong regression testing and CI validation to ensure stability. Deliverables: Consistent and well-defined /api/v1 API behavior with improved validation and error handling. Hardened authentication and mutation route reliability. Completed frontend views (stats, symfiles) with contract-aligned data handling. Expanded backend regression tests and improved documentation. Final implementation report and follow-up issue roadmap.

<p>PCLm is a file format which is a light-weight subset of PDF which makes printing fast and efficient. It is streamable, i.e. can be printed page by page unlike PDFs, where PDF files require them to be loaded completely to the printer memory to be printed. Many cheap printers which are low on memory have this limitation of printing large PDF files, and here PCLm comes to the rescue. It also makes printing faster for high end printers. PCLm is also one of the standards for Wifi-Direct IPP printers. The project aims at enabling PCLm printing using cups and cups filters to PCLm supported printers.</p>

<p>Automated layout web service with an integrated converter, to change the format of the data, would be of great use for people who want to quickly and easily layout their data to some of the famous cytoscape.js layout extensions</p>

<p>This project aims at developing a tool which should provide an interactive visualization of the cancer progression models produced by the R library TRONCO. In particular, the web application will have two main functionalities: it will provide an interactive graph display and it will supply cancer progression models generation by directly calling the TRONCO functions. In addition to that it will provide the users with information about the genes involved in the model.</p>

<p>This project is focused to implement a new interface between Rocket.Chat, Omnichannel Livechat widget and Rocket.Chat.js.SDK allowing Agents to get real-time screen-share on customer’s devices.</p> <p>The main goal is to add the core features in Rocket.Chat, Rocket.Chat.Livechat and Rocket.Chat.js.SDK to support any screen sharing provider and to implement a generic screen-sharing manager to allow integration of any screen-sharing providers (by using dependency inversion principle) and to benchmark the server performance in updating sessions and rooms and declaratively loading JS scripts on live chat widget.</p>

<p>Wayland is a set of protocols for communication between applications and compositors that is expected to replace Xorg in the Linux graphics stack in the next years. Mainline Kodi currently lacks support for Wayland and must thus use an Xwayland-emulated X11 session for display which is not optimal in the long run. Therefore, native support for Wayland should be implemented in Kodi.</p>

My project aims to address the challenge of navigating and accessing artifacts within Scala projects on Scaladex. Currently, users face difficulty in efficiently exploring and accessing all artifacts associated with a project due to the lack of a dedicated Artifacts page. To solve this problem, I propose to introduce an intermediate Artifacts page, enhancing project visibility and artifact discoverability. The project will deliver a fully functional Artifacts page integrated into Scaladex, providing users with a seamless and intuitive interface to explore and access artifacts associated with Scala projects. Documentation detailing the implementation process and testing outcomes will also be provided for future reference.

This project aims to migrate the existing Scala documentation website from Jekyll to Scaladoc. This migration will provide a more streamlined, modern, and easily maintainable documentation experience that is tightly integrated within the Scala ecosystem. I will focus on replicating key Jekyll features, such as the "include" mechanism and custom tabs, using the "liqp" library within the Scaladoc framework. Existing content (Markdown, HTML, CSS) will be carefully adapted, and styling will be applied to match the look and feel of the current website. If time permits, I will explore additional customizations to Scaladoc's default output for greater layout flexibility. The key deliverables of this project include a functional MVP website, replicated Jekyll functionality, and comprehensive documentation of all implemented features.

FS2 is a key part of the Typelevel ecosystem for streaming I/O operations in Scala, offering powerful APIs that provide a wide range of functionality for different use cases. However, its use in smaller scripts often introduces unnecessary complexity and boilerplate, hindering productivity and accessibility. This project proposes the development of Fs2 OS, a fluid and intuitive library designed to revolutionise the way developers interact with files and processes.

Cyfra is a GPU runtime and DSL that simplifies GPU programming in Scala by abstracting Vulkan. This project will build a real-time rendering pipeline with outputs to a window, data stream, and file. Deliverables include high-level GPU APIs, GLFW integration, efficient swap chain/synchronization, and clear documentation with examples—making high-performance graphics more accessible to Scala developers.

This project implements the idea “Semantic highlighting in VS Code” * in the Scala Center. Summary of process is as follows. 1. Building the VS Code semantic highlight framework into Metal. 2. Implementing "vscode.SemanticTokensBuilder'' for Scala (perhaps using the presentation compiler of Scala). 3. Taking care of other factors (test plan, settings, and Non-functional requirements) *https://github.com/scalacenter/GoogleSummerOfCode2022#semantic-highlighting-in-vs-code

This project focuses on building a seamless API integration between MS Teams and the ChatOps4s prototype through a clean, efficient interface. The key goals are to ensure high performance, minimize dependencies, and maintain feature parity with other integrations, such as Discord. The MS Teams API interface will be well-documented, rigorously tested, and designed for interoperability, allowing developers to switch to another platform, like Discord, with minimal code modifications.