Explore Projects

Add zero-config authentication and cookie handling support for Next.js App Router server actions and middleware.

<p>Training of High end Deep Learning Models takes a Long time to Train, Hours, Days and Even Weeks. So, as a Developer/researchers it slows down the creativity and implementation cycle. The Whole Idea of Transfer Learning provides a nice solution where a model trained on a similar dataset can be trained partially or fully, on the custom dataset, yielding similar result. TFHub is a platform by Tensorflow where pretrained models are shared, so that developers and researchers can use transfer learning on these models. In this Project I'll be working on the following tasks:</p> <ul> <li>Implement Tensorflow Hub sample for Cloud TPU</li> <li>Convert ShuffleNet from ONNX to TF Hub Module</li> <li>Implement and Train ESRGAN(Enhanced Super Resolution Generative Adversarial Network) from Scratch (<a href="https://arxiv.org/pdf/1809.00219.pdf" target="_blank">https://arxiv.org/pdf/1809.00219.pdf</a>)</li> <li>Implement GAN Distillation to compress ESRGAN (<a href="https://arxiv.org/pdf/1902.00159.pdf" target="_blank">https://arxiv.org/pdf/1902.00159.pdf</a>)</li> <li>Add Support for SavedModel 2.0 Functions in saved_model_cli</li> <li>Add Sample Notebook demonstrating usage of ESRGAN TF Hub Module</li> <li>Create proof of concept Video player for real time video frame Super Resolution (using "distilled" ESRGAN)</li> </ul> <p>Github: <a href="https://github.com/captain-pool/GSOC" target="_blank">https://github.com/captain-pool/GSOC</a></p>

This project aims to implement a daemon that serves as a build system manager for modules, providing support for explicitly built modules irrespective of the build system. By simply incorporating a single command line flag, each Clang invocation registers its translation unit with the daemon, which then scans the unit's dependencies. As translation units are registered and analyzed, the daemon constructs a dependency graph for the entire project. Concurrently, it utilizes the emerging graph to schedule and build each module's AST. This approach allows for a single, comprehensive entity to effectively coordinate and manage the build of modules throughout the entire build process.

Scaladex, the central index for open-source Scala libraries, currently does not have dedicated support for Scala compiler plugins—special artifacts used to extend or modify compiler behavior. These plugins are vital tools in the Scala ecosystem but are difficult to discover due to lack of indexing and classification. This project proposes adding full support for Scala compiler plugins in Scaladex. The implementation includes extending the binary version parser to recognize plugin naming conventions, adding a new platform type (CompilerPlugin), and integrating plugin-specific metadata into the indexing pipeline. The user interface will be updated to allow filtering and discovery of compiler plugins, and best practices for plugin authors will be documented. The key deliverables of this project include: Parsing and indexing improvements to recognize compiler plugin artifacts. UI enhancements for discoverability, including tags and platform filters. Updated documentation and contribution guidelines for plugin maintainers. A technical blog post summarizing design decisions, edge cases handled, and outcomes. By implementing these features, this project will significantly improve the visibility, discoverability, and usability of compiler plugins in the Scala community.

The proposed solution introduces comprehensive tracing capabilities to the LLM4S toolkit by integrating OpenTelemetry (otel4s) for capturing detailed spans and metrics during LLM operations such as prompt construction, model invocation, and response parsing. These telemetry signals are exported in Prometheus and Jaeger-compatible formats and processed through the OpenTelemetry Collector. The data is then visualized on a unified Grafana dashboard, allowing developers to monitor performance, debug errors, and analyze execution flows across different LLM providers in real-time.

A common feature that most build tools supports common source code generator such as Protobuf or Smithy. The idea of supporting code generator has been existed for a while, with some of the features such as the execution of the source generator already been implemented in Bloop. The goals of this project is to improve upon the already existing feature for Scala CLI.

In Metals, the LSP implementation for Scala, there is currently no built-in support for Play Framework-specific files such as .scala.html templates and routes files. This limitation affects essential features like syntax highlighting, linting, and navigation, making it difficult for developers to work efficiently with Play Framework projects in editors that rely on metals. eg. VSCode. This is exacerbated by people who wish to migrate from proprietary editors like IntelliJ which provides such facilities.

<p>The name Scala comes from the word scalable, and true to that name, the Scala language is used to power busy websites and analyze huge data sets. Scala is one of the leading languages in implementation of big data systems. It is widely used in streaming data. Similarly, Python has become the language of choice for data scientists with its many high-quality scientific libraries. ScalaPy is that bridge which gives an opportunity to use Python libraries in Scala. Last year a new version of Scala was introduced. At the moment it is not released but Scala 3 brings many new features and changes. The aim of this project is to discover those new features and implement support for ScalaPy in Scala 3. ScalaPy will possibly help Scala 3 to become more popular among scientists and maybe this will be the core moment in combining data processing and data analysis worlds in Scala 3.</p>

LLM4S aims to establish Scala as a premier language for building multimodal Large Language Model applications. This project extends the toolkit's capabilities beyond text processing to support image generation, speech-to-text, text-to-speech, and multimodal embeddings. By leveraging Scala's type safety and functional programming paradigms, we will create APIs that enable seamless integration of visual, auditory, and textual modalities while maintaining enterprise-grade reliability. The implementation will bridge Python-centric AI ecosystems with Scala's performance advantages, offering developers a robust alternative for building complex multimodal AI systems.

Cyfra is a GPU runtime and a DSL that makes Scala a viable choice for GPU programming. Currently, the Scala ecosystem does not have an easy-to-use library for doing general computations on the GPU. Cyfra aims to fill this gap. Goal of the project is to implement support for GPU computations on data streams, with focus on usability, and integration with the popular fs2 (Functional Streams for Scala) library, which is used widely in the Scala ecosystem. Cyfra should enable developers that do not have background in GPU programming to write a simple data processing pipeline in Cyfra that performs compute on GPU and efficiently manages memory. The pipeline should be interoperable with fs2. Integrating Cyfra's pipeline with fs2 will also make it compatible with major Scala open source libraries, opening them up to execution on the GPU.

Native CSS Support is capable of replacing mini-css-extract-plugin, style-loader and css-loader, with better support for Hot Module Replacement (HMR), In the future, handling CSS could become more convenient without relying on third-party loaders and plugins. Currently, Native CSS still has many issues, which you can check out at https://github.com/webpack/webpack/issues/14893. This includes support for various import methods, CSS minimization, preload/prefetch CSS files, and magicComment support, among others. Many of these functionalities can be implemented based on the JavaScript module's implementation. Additionally, there is a need for further research and modification of the CSS

EmbeddedChat is Rocket.Chat's embeddable chat widget, but RC 8.x broke several core endpoints, Matrix federation support is absent, there is no AI extensibility point, mobile responsiveness is inconsistent, and WCAG compliance is incomplete. This project restores RC 8.x compatibility and completes the DDP client migration, adds production-ready Matrix federation via a mode prop backed by an upstream RC core fix, introduces a standalone provider-agnostic AI adapter package, systematically fixes mobile viewport issues, and brings the widget to WCAG 2.1 AA compliance. Working POCs exist for all five goals

The Talawa app as we know should support the chat functionality among users as well as the user and the organization.I have been working on the chat functionality as a part of the Github Externship Winter Cohort.The basic features of the chat has and will be implemented by the end of April.While working with the code base ,one of the most major important feature which should be there for any management app is that there should be a persistent ,stable cloud file storage system which will help in sending of files between the users of the app.Besides sending file,the cloud file storage system will also be helping in storing essential multimedia which is also a very essential feature and of high priority This proposal intends to complete the backend API support for multimedia storage and also sending of media over chats. The cloud service we will be implemented using Firebase storage.

<p>The goal for this project is to integrate chatbot platforms like Dialogflow and RASA with Rocket.Chat.</p> <p>These integrations are built to work with the Livechat module of Rocket.Chat. Livechat is a modern helpdesk application that helps connect a live-agent with a visitor so that the live-agent and answer visitor's queries.</p> <p>With these new Integrations of Dialogflow and Rasa, Rocket.Chat will now allow site visitors to interact with a Bot instead of a live-agent. These Bots would be developed and maintained on Dialogflow and RASA.</p> <p>This is a very common approach which most of the businesses use nowadays, where a visitor would first interact with a Bot. These bots can handle simple interactions like answering FAQ's for a business, to complex interactions like ordering an item. If these bots are not able to answer visitor questions, then the visitor would be transferred automatically to an online live-agent who can address their query.</p>

<p>I chose the project ‘Theme Support for Rocket.Chat Android App’ because it integrates my two loves of android development and strong visuals and graphics. I am passionate about UI/UX design and implementation. Being a freelance graphic designer, artist and programmer, I think I would be a unique member to have on board the Rocket.Chat open source community.</p>

Until recently, explicit module builds were only supported for Clang modules. With the -fmodules-driver mode upstream patch being merged, the community can finally experience explicit builds for both Clang modules discovered through module map files and C++ named modules. However, one of the main advantages of modules is their ability to being cached. Currently, -fmodules-driver does not support this. Therefore, the proposal strives towards an effort to bring forth an efficient, correct and safe filesystem cache. The proposed filesystem cache will enforce strong concurrency control. Once this cache system is fully implemented, the community will be able to use and manage it with existing Clang flags along with -fmodules-driver mode.

<p>The advantages of organizing a program into several files or modules are similar to authors organizing a book into several chapters and sections. The structure helps people who aren’t yet familiar with the code find what they are looking for and makes it easier for the programmer to keep things that are related close together. This project aims at developing a module system for the wonderful Hammer.js library that is flexible, predictable and extensible in the new ES6 version of javaScript.</p>

<p>In this project, File API and related functionalities will be completely implemented in the <a href="https://github.com/servo/servo" target="_blank">Servo browser engine</a>. With these features landed, the end users can upload files through form submission and interact with the local file content directly in browser; the developer will be endowed the ability to read local file content programmatically in either sync or async way, create Blob URL and use them in a very flexible way. In addition, a dialog UI will be integrated to support file picking.</p> <p>For more information, see <a href="https://github.com/izgzhen/gsoc-file-support" target="_blank">the meta-tracker of this project</a>.</p>

This project aims to modernize Webpack by implementing comprehensive support for ECMAScript Modules (ESM) output. Webpack currently lacks robust ESM output capabilities, creating challenges for developers working with modern JavaScript. The implementation will focus on four key areas: parser and module analysis enhancements to detect strict mode compatibility issues and identify statically exportable modules; code generation improvements to properly transform CommonJS to ESM exports; runtime optimization to eliminate unnecessary boilerplate; and platform-specific feature support for CSS modules, URL handling, and ESM workers.

<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>This project focuses on the improvement of the live capture section implemented in the spectral workbench app at <a href="https://spectralworkbench.org/capture/" target="_blank">https://spectralworkbench.org/capture/</a> to make use of the spectral-workbench.js library after adding some enhancements to it. Additionally, this would require the new live capture code to be adapted to interface with the rails server in order to fetch recent spectral calibrations, display them in a dropdown, then make use of the chosen calibration spectrum to display a scaled x-axis on the live capture interface graph before finally handing off the calibrated data to the rails app.</p>

The OpenPrinting website is an essential platform for Linux printing resources. The current system lacks modern UI enhancements and optimized SEO. Additionally, the existing Foomatic lookup page relies on SQL and dynamic web technologies, which I will be migrating to a fully static implementation. This transition will eliminate dependencies on an SQL server and a web server, with everything being managed exclusively on GitHub. This project aims to modernize the OpenPrinting website by migrating it to Next.js, a powerful React framework that ensures scalability, performance optimization, and maintainability. The transition will include: - Rebuilding the site with a modular, component-based Next.js architecture. - Migrating the Foomatic lookup page to a static page for improved efficiency. - Implementing Server-Side Rendering (SSR) and Static Site Generation (SSG) to optimize performance. - Deploying the new website with a CI/CD pipeline for automated updates and maintenance.

This project proposes to explore the potential of Tauri as a replacement for Electron in the Rocket.Chat Desktop App. However, Tauri is currently not mature enough to be used as a replacement for Electron. Therefore, this project aims to test the current capabilities of Tauri by comparing it to the existing Electron-based app and analyzing its limitations. The project will involve building a prototype of the [Rocket.Chat](http://Rocket.Chat) Desktop App using Tauri, implementing all the current features that the Rocket.Chat Desktop App currently has such as notifications, download manager, auto updater, settings manager, trayicon etc and comparing its performance to that of the Electron-based app.