Explore Projects

Volto is structured as a typical Redux-centered React application. The refactoring class components to functional components project is centered around using concepts of hooks to migrate class components to functional components and testing the refactored components with Cypress tests and Storybook to verify the UI is intact, after, all the tasks are delivered performing e2e testing.The lifecycle of the components should be preserved while watching out for edge cases and UX problems.Delivering appropriate documentation for the changes made.

The objective of this project is to create adaptable web components using UI frameworks like Microsoft's Fast. This will involve expanding the existing component suite and implementing design tokens to create a user-friendly interface for the GA4GH Workflow Execution Service (WES) and Task Execution Service (TES) APIs. The ultimate goal is to integrate these components into the Krini web portal, providing an intuitive and responsive interface to facilitate complex genomic and biomedical computations.

The proposed React Native SDK will expose React Native components with a similar functionality of the already known Jitsi Meet Native SDK classes. These Native SDKs are utilising a React Native Component at their core that exposes Jitsi’s functionality for native mobile apps. The React Native SDK classes will communicate directly with the existing core component using props and offer the customisation options known from the native SDK. The deliverables are: - A React Native SDK containing the complete functionality of the native SDKs - A test suite for the SDK - An API reference with examples

<p>Reliability is essential for communication using XMPP. Although basic XMPP is not reliable in some situations. One of these situations is losing long-lived TCP connection between client and server or server and server because of network or destination failure. If this connection isn’t properly closed, sender will be unaware of the loss and connection will appear as open to server until TCP timeout is reached. All messages which will be sent by server during this time will be lost.</p> <p>The goal of this project is to implement XEP-0198 for server-to-server communication in ejabberd. This extension allows to request stanza acknowledgement and quickly resume session. Any messages that were not delivered over previous connection will be retransmitted during session resumption without duplication.</p>

This project aims to create a Rocket.Chat App that acts as an AI Assistant Agent, improving onboarding and community management through a conversational interface. The app engages new users with a tailored chat, delivers a welcome message, shares server rules, and recommends relevant channels based on their needs all of which can be configured by admins. It also auto-assigns default rooms and allows users to perform common tasks like joining or leaving channels, inviting others, or using other app features without remembering Rocket.Chat slash commands , making servers more approachable for newcomers

The ultimate goal of the project is to create a full-stack React component node module of the RocketChat application that would be fully configurable, extensible, and flexible for use. It will allow users to integrate RocketChat into their React web-based applications easily also providing an amazing developer experience while creating in-app chat applications.

RocketChat UIKit Playground is a proposed Component playground that will allow us to build, test, and browse our UIKit components in isolation. When executed correctly, they make prototyping new experiences both easy and fast, thanks to the consistency they create. The playground should also allow developers to generate configuration by dragging and dropping components from the library. Deployed Here --> https://intvivek.github.io/RCplayground/

The goal of the project is to implement distributed tracing in order to trace individual calls between multiple backend components. The implementation can be broken down into the following stages: Infrastructure: Deploy an OpenTelemetry colector, and a Tempo tracing backend; Instrumentation: Instrument backend components in order to send events to the collector; Tracing: Stitch events together into traces by propagating trace context; Polishing: Iterate the generated events in order to improve the observability of the system; Documentation: Document how to deploy the required components, how to add/modify generated events, and how to visualize the data.

For my GSoC project, I wish to implement bigger full-stack features while continuing to investigate and fix bugs in the areas I'm familiar with. These areas include the settings panel, user Profile, compose box, popovers, message feed UI, and left sidebar. The issues I specifically aim to solve this summer are: - Unmute Topics within a muted stream - Add subscribe widget to user profile popover - Unsubscribed tab in stream settings - Make it possible to cancel uploads - Show empty conversation in left sidebar - Migrate manage user/bot to user profile - Special title and bug fixes for narrow titles. - copy drafts feature - Major bug fixes in user profile modal.

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 builds a Gemini CLI extension that solves MCP's context bloat problem for Rocket.Chat developers. Current MCP servers expose an entire platform's API surface, meaning every agent session wastes tokens on hundreds of tool definitions the project will never use. The Minimal MCP Server Generator lets developers describe their use case in plain English and produces a production-ready MCP server covering only the endpoints they actually need. The generator goes beyond raw API wrappers by composing multi-step workflow tools: declarative step graphs that chain API calls, AI reasoning, conditional branching, and data transforms into single high-level operations. It supports two compilation targets: a standalone webhook + REST server that runs anywhere, and an Apps-Engine bridged mode for realtime event interception. The key deliverables include: a Gemini CLI extension with endpoint discovery, schema lookup, and project generation tools; a six-pass workflow validation pipeline that catches and self-corrects LLM mistakes before codegen; additive tool generation that adds new tools to existing servers without overwriting; protocol-level test generation via MCP Inspector; runtime hardening with endpoint allow-lists; and a PlatformProvider abstraction with a Mattermost dry-run proving the generator's portability beyond Rocket.Chat. This approach reduces token costs, fits within free-tier limits, and makes MCP-based Rocket.Chat development accessible to any workspace regardless of plan.

<p>Currently, the process of generating the documentation is manual and it requires updating the docs every time there is a change in props. We can use document generator tools to generate documents effectively using scripts. Work on internationalization of documentation. Along with this make a Web App which showcases components.</p>

This project aims to develop an intuitive Message Timestamp Date Picker for Rocket.Chat, replacing manual timestamp code entry with a user-friendly UI component. Currently, users must manually type complex codes like <t:1732557600>, which creates friction and is error-prone for non-technical users. I will solve this problem by implementing a comprehensive system with three layers: Core Utilities for timestamp conversion and validation, UI Components creating an intuitive modal with selection options and preview, and Integration Layer connecting to Rocket.Chat's existing systems. Deliverables include complete timestamp utility functions, TimestampPicker modal with intuitive inputs, message composer integration, rendering system for displaying formatted timestamps, comprehensive testing, and documentation. The solution will support all timestamp formats across platforms, significantly improving user experience when communicating time-based information.

<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>Our React native implementation is relatively newer than its native counterparts hence lacks many of the important features and is more buggy. The aim here is to implement some of the important features that the application lacks, and also side by side replacing some legacy libraries with a new one to increase performance as well as user experience and last but not least resolving discovered as well as undiscovered bugs. I think the most important feature that app lacks is the ability to fully share files. It can right now download and view already shared files but there no way to upload a new one. Second, an important feature that really makes Rocket Chat standout from others are slash commands, It allows the user to do trivial actions, like invite a user or archive a channel in fewer tabs Third, add in app notification so user can be notified even when he is using app<br> And last but not least I will be redesigning the settings panel of app and adding new options to it like Licence and contact us</p>

<p>The Rocket chat team has been sincerely working on improving the Android App by regularly adding great features and making them available to users through updates on the Google Play store. Play store is a great platform for making the app available to all users but there are countries where play services are banned/not available. Hence there is a great requirement for other app hosting platforms so that people of these countries can also use Rocket.Chat apps. This problem can be solved by using F-Droid. F-Droid is a community-maintained software repository for Android. Apps hosted on Fdroid can be installed from the F-Droid website or client app without the need to register. Being a catalog of Android FOSS applications. It is available in almost every country in the world. Rocket chat legacy android client is recently replaced by React Native and needs to be updated on F-Droid, Apart from this there are few other features like integrating Fastlane in the android module and use it to run the existing jobs and create a new job to upload the build to play console Other features include Improving CI workflow and create jobs to generate separate builds for both Fdroid and Play store.</p>

This project is a significant upgrade to Rocket.Chat message composer elements to provide users, AI assistance in writing messages using Context-sensitive spelling corrections, inline grammar correction recommendations, and clarity-enhancing rewording, Inline hinting are among the major features. The project also provides language translation, summarization, emoji, and tone control features. This project majorly improves the speed and clarity of message writing for users.

<p>Implements a Share extension to iOS and Android OS to ReactNative client Rocket.Chat.</p>

<p>The project Rocket.Chat.ReactNative is already about 2 years old and there are lots of features. So the chances of introducing new bugs by changing the existing code or adding new features are really high. And before each build the application needs a thorough testing to make sure nothing is broken.</p> <p>Currently project has some end-to-end tests for IOS platform but unfortunately no tests for Android. And also the Continuous Integration job on Circle CI with IOS tests is failing, the build stays always ‘red’.</p>

This project addresses the absence of HTTP streaming support in the Rage framework, where responses are currently fully buffered before being sent to the client. This limitation prevents real-time use cases such as incremental LLM outputs, live data feeds, and large streaming responses. Even when applications generate data in chunks, the Iodine server collects all output into a buffer and sends it only after completion, making true streaming impossible. To solve this, the project introduces native HTTP streaming using chunked transfer encoding across both Iodine (C layer) and Rage (Ruby layer). A new streaming path will be added to Iodine to support incremental writes with a robust backpressure mechanism, ensuring the event loop remains non-blocking. On the Rage side, a developer-friendly API (render stream:) will be implemented using enumerators and fibers, allowing applications to stream data declaratively while seamlessly handling pause/resume behaviour under backpressure. The deliverables include implementing the http_stream transport, a Rack-compatible streaming writer with lifecycle and backpressure management, and the Rage streaming API. The project will also provide integration tests, edge-case handling (e.g., disconnects, high load), and updated documentation. This enables real-time streaming in Rage while preserving compatibility and supporting future extensions like HTTP/2.

Joplin's offline-first design is one of its best features, but it comes with a real cost when the same note is edited on two devices before either syncs, Joplin has no way to merge the changes. It saves one version as a conflict note and leaves the user to manually figure out what to keep. For long notes on mobile, most people just give up and pick whichever version looks more complete, which means changes get silently lost. This project adds an interactive conflict resolution UI to Joplin desktop and mobile. When a conflict note is opened, instead of seeing a raw copy with no context, the user gets a clear section-by-section view of exactly what each side changed. Non-conflicting changes like additions and deletions can be resolved in one click. Genuine conflicts where both sides changed the same part give the user full context to pick one side or edit manually. A Keep both option preserves both versions for users who want that. The same shared diff module powers both platforms so the behaviour is always identical. The core deliverables are a platform-independent diff module using node-diff3, a minimal addition to the sync pipeline to store a base snapshot for three-way merging, and a conflict resolution React component for desktop and React Native component for mobile. The implementation also handles edge cases including notes synced before the feature was deployed falling back to two-way diff, stale remote data being detected and reset on open, and second conflicts on the same note being handled gracefully. No existing conflict behaviour changes and sync is never blocked at any point.

<p>Libraries for <a href="https://github.com/apple/swift-log" target="_blank">Logging</a> and <a href="https://github.com/apple/swift-metrics" target="_blank">Metrics</a>, embraced by the Serverside Swift Work Group, have enabled many Swift projects to simplify their code bases by removing their own implementations. However, there’s currently no official story for distributed tracing.</p> <p>This project aims to kick off the work on a distributed tracing infrastructure for the Swift ecosystem by creating a context propagation library with integration points for Swift NIO, AsyncHTTPClient, Swift gRPC, URLSession, and more.</p>

Implement full WAI-ARIA 1.2 screen-reader keyboard interaction models with localized calendar formatting.