Explore Projects

Flood is a monitoring service for various torrent clients. It's a Node.js service that communicates with torrent client and provides a user-friendly mobile UI for administration. It has great features such as the ability to use magnet/torrent files to download torrents, support for RSS feeds, the ability to select torrent files to start downloads from any location on your device (e.g., File Explorer, WhatsApp), notification action support, and many more. My primary goals would be to, make the Flood-Mobile app scalable through state management migration, create a testable app, implement a feature for changing languages, develop a customizable user interface, improve the app's power management, enhance notification support, add various sorting functionalities for torrents, and implement the CICD tool fastlane in the app.

<p>The Sugar Journal doesn't do a great job of supporting versioning or forking. This project is to build a backend for the Journal and Turtle JS that is based on git, which does support versioning and forking. This project will also help the end user i.e., students and teachers to understand the concept of git. We also get the benefit of network access by building on the top of a git hosting site</p>

<p>There is currently no open source API specification format and schema converter API that provides conversion between multiple formats. The proposed project involves integrating a number of API format and schema converters into a single converter that will be used to convert between a number of supported formats. Endpoints for the converter would be developed using Node.js. Following the integration, endpoints will be exposed to end-users via React.js.</p>

Beacon is a cross platform mobile application made with Flutter for the frontend and supported by Node.js and GraphQL for the backend. It's a handy tool for planning and managing group hikes, offering features like tracking leaders location in real-time, showing routes dynamically, sending emergency alerts, and easily sharing locations. Using Flutter makes Beacon easy to use on different devices. By connecting with Node.js and GraphQL, it ensures quick updates and smooth navigation during hikes, making outdoor adventures safer and more enjoyable for everyone involved.

<p>The idea is to</p> <ul> <li>Add a new Database honeypot module - as for now there are modules like ssh,ftp,https and ICS but no module for catching database events.</li> <li>Add telenetsrv honeypot module to the system - as for now there are modules like ssh,ftp ,https and ICS.</li> <li>Add IMAP honeypot Module to the system - as for now there are modules like ssh,ftp ,https and ICS.</li> <li>Add SMTP Honeypot Module to the system - as for now there are modules like ssh,ftp ,https and ICS.</li> <li>Enhance the Web UI - Search functionality in the UI and also make the visualizations more better and presentable.</li> <li>Make small changes like export the data via UI and after the termination of the honeypot server in a nicely formatted JSON and CSV - currently only stored in the database.</li> <li>Add tests for all the functions inside the modules - as we have newly created the Test environment, I would like to add tests in the system.</li> <li>Docker Image - The idea is to create a docker image of the Honeypot process as currently one has to run it via script. To automate this process I would like to make a Docker Image and put it on Docker Hub to make it easier for some other company/user to use the Honeypot system.</li> </ul>

George Vaindirlis coded a MPD server module for VLC last year. This project aims at finishing his work by adding support for more features from the MPD protocol and testing it with several MPD clients.

<p>Add lock button, Equalizer UI, Track management, Next &amp; Previous button MediaElement, extend gesture support, Add docs on how to custom style/bind the LibVLCSharp.Forms MediaElement</p>

Remove circular imports, integrate sentry into the project, integrate Prometheus in API's to view metrics in grafana, add a new panel in the UI to view all the details of running modules, adding test cases to test out whether running containers are shutting gracefully or not under various conditions, adding verbose logging support, updating wiki for all the new features.

This project plans to implement a more accessible version of the current Kolibri PDF Renderer. It currently does not support some basic features of a PDF reader reader such as selecting the text, making annotations, and an outline of the pages, among others. The objective of this project is to update the current PDF renderer plugin with a newer version of the PDF.js library that allows basic activities typical of a PDF Reader.

The next version of Music Blocks (v4) is currently setup using create-react-app, a widely-used tool but lagging behind in certain key dependency updates. As a result of which certain development features like Hot Module Reloading, are broken. This project aims to take advantage of this lapse and upgrade the core development tooling of the entire project, making it more seamless, with small developer experience upgrades, along with much needed dependency upgrades to make local development fun and fast. Along with these improvements, the project will also tackle the problem of improving production bundle size for faster loading, and creating a Progressive Web App for offline usage.

The project aims to replace the outdated Flask-based SwitchMap-NG interface with a modern, high-performance frontend built using Next.js and React. It focuses on creating an interactive and responsive platform for network monitoring, featuring dynamic topology visualizations, detailed device analytics, and historical performance tracking powered by vis-network and Recharts. Performance optimizations such as caching, lazy loading, and memoization ensure scalability and efficiency for large datasets. The new architecture includes complete configuration management, automated documentation, and rigorous testing to achieve high test coverage. Overall, the project delivers a sleek, maintainable, and insight-rich UI that significantly enhances usability, performance, and network visibility.

Reinstating automated threat suggestion per element was a feature in the threat dragon threat model designing system. Hence, upon migration to Vue.JS framework, not all features where migrated as that would take much effort to be completed. Yet, the project is continuously reinstating old features with new ones to make threat dragon an even better threat model designing system. This specific project is about suggesting threat type automatically for an element upon creation when drawing a threat model. My solution is about tracking our current existing threats for this element. and upon creating a new threat, the algorithm would check the existing threats and with the map it has for matching suggestions, it would pick the threat type suggestion for the next created threat.

In an era where cybersecurity threats evolve rapidly, the Open Web Application Security Project (OWASP) Bug Logging Tool (BLT) serves as a crucial line of defense, enabling the identification and management of vulnerabilities. My proposal aims to significantly enhance the OWASP BLT's effectiveness by integrating advanced AI capabilities, addressing the current limitations around bug reporting, triage, prediction, and user engagement. Deliverables: * A fully integrated AI chatbot for the OWASP BLT website. * An AI-enhanced bug report page with NLP support for detailed descriptions. * An automated bug triage system using machine learning. * A predictive analytics tool for future bug identification. * An NLP-enhanced bug search functionality. * A revamped user dashboard with updated design and features. * A user feedback loop mechanism with a voting system. * An improved Slack module with AI capabilities for bug management.

Neutralinojs makes it easy to build lightweight cross-platform desktop apps, but distributing them is still fragmented. Developers currently rely on external tools like AppImage, NSIS, or Debian packagers to create installers for each platform, leading to inconsistent workflows and added complexity. This project proposes Neutralinojs Builder, an official CLI plugin that simplifies and standardizes installer generation while keeping the core neu CLI minimal and platform-agnostic. The solution will be a Node.js-based CLI plugin that introduces a neu builder command to generate platform-specific installers (e.g., NSIS for Windows, DEB/AppImage for Linux) through simple commands or configuration. It will follow a modular design where each packaging target is implemented as a dynamically loaded internal module, ensuring scalability and a lightweight codebase. The project will also explore Neutralinojs SEA (Single Executable Applications) to further improve portability and distribution. This project aims to provide a unified and efficient packaging workflow for Neutralinojs developers.

The proposal outlines a high level plan to port the Hardsubx module to Rust. The proposal intends to port Hardsubx to Rust with the minimum amount of rewrites required while ensuring maximum memory safety through various stages. The final version of Hardsubx will have the exact same external interface as the old one. The live document is available in this url for feedback and changes: https://docs.google.com/document/d/1U9RqfbjfVNUkUYOBzT6yn1ANLGo_v58wtepslbQhtV4/edit?usp=sharing Edit: - Add support for tesseract cube engine for better performance in extracting burnt-in subtitles - Update subtitles for tests because the different tesseract engine will generate different subtitle files from before. Edit2: - add promising rust wrapper options for Tesseract, Leptonica, and ffmpeg Edit 3: - divide the timeline phases into mostly biweekly periods Edit 4: - add guarantees on subtitle quality in the deliverables - add contingency on LSTM replacing the current system. Now, in the experimentation period we need to determine if the computational tradeoff is worth it for using an LSTM. Edit 5: - add deliverables for first evals - add other possible commitments in the GSoC period

This project focuses on improving the TaskWarrior Flutter mobile application by reducing technical debt, improving the Rust–Flutter integration, and expanding core TaskWarrior functionality on mobile platforms. The current codebase contains legacy synchronization components, incomplete Rust FFI features, and an unstructured project layout that makes maintenance and feature development difficult. The project will remove the deprecated CCSync synchronization layer and unify synchronization through the TaskChampion Rust backend. The tc_helper Rust library will be refactored to improve build configuration, modular structure, cross-compilation, and to expose missing task attributes to the Flutter application. The Flutter project will also be reorganized into clear modules separating legacy Taskwarrior 2.x code from the TaskChampion implementation. Additionally, a mobile reporting engine will be implemented to support Taskwarrior-style filtered reports and user-defined configurations. A GitHub Pages website with automated nightly build tracking will also be created, along with targeted UI and UX improvements based on community feedback. Deliverables include synchronization refactoring, Rust library improvements, Flutter project restructuring, a reporting engine, project website, and UI/UX enhancements.

To improve user experience and remove the need for manual downloads and installations, this proposal aims to automate the Joplin desktop application's update process. The main objective is to make sure that, for users of Windows, Linux, and macOS, the app updates without any problems in the background, downloading and installing the updates automatically when the program restarts. Investigating real-time updates and creating plans for updating files that are already in use are secondary objectives. For application updates, the project will make use of Electron and electron-builder together with TypeScript and React. Using Electron's autoUpdater module to manage downloads and updates, setting up a background service for silent updates, constructing a non-intrusive user notification system, and ensuring flawless application restarts for updates are important tasks. There will be testing and documentation at every stage of the development process. The timeline spans 14 weeks, starting with initial setup and planning, followed by developing the background update service, implementing the automatic installer and notification system, integrating and testing the updates across all supported platforms, and addressing any unforeseen challenges. The final stages will focus on finalizing documentation, polishing the update mechanism for deployment, exploring live updates, and project wrap-up with mentor review and project submission to Joplin and GSOC.

The goal of this proposal is to add BLAS (Basic Linear Algebra Subprograms) routines and their C, Fortran, and Js implementations for linear algebra. There are three levels for BLAS: Level 1 is for vector-vector operations, Level 2 is for vector-matrix operations, and Level 3 is for matrix-matrix operations. I propose to add the Javascript, C, and free form Fortran implementations for the routines using the fixed form Fortran implementations available. For each package, I will add thorough benchmarks, comprehensive test suites, examples, and a README containing the API signatures for the routine in multiple languages, along with the ndarray case. I will also add the docs folder, which houses a repl.txt file, a typescript file that provides introductions, usage instructions to aid in documentation, and other files to check cases where the function may become invalid. A cblas wrapper will also be added for devices with support for cblas, such as AppleAccelerators, for hardware-optimized performance. This implementation will open doors for domains such as time series analysis or linear algebra operations such as SVD that are built on top of these BLAS routines. A comprehensive suite of BLAS routine APIs will be incorporated into stdlib, and the integration of C and Fortran implementations will aim at optimizing performance and enabling potential hardware-based implementations.

<p>ZAP has good support for websockets, and allows them to be intercepted, changed and fuzzed. However, it doesn't currently support scanning, either passive or active, of websocket messages. Thus, it is necessary to start with an infrastructure that is going to support scans, both active and passive. The infrastructure should handle the addition and removal of plugins, providing appropriate utilities, run in a background thread, may store statistics of scanning, etc. On the other hand, a plugin implements a particular scanning method for a group of vulnerabilities. Script plugin is a special kind of plugin which is used to run scripts which are written by users and consequently processed by different scripting engines. Finally, API is useful for inter-connectivity of ZAP with other applications like ZAP HUD. I proposing a infrastructure which is going to support active and passive scanning. In addition, I am proposing feature which in my way of thinking is essential and plugins which are testing the most critical vulnerabilities.</p>

<p><strong>OWASP OWTF</strong> is a great tool which automates the manual and non-creative work of penetration testing. It combines all required tools and features but lacks the <strong>monitor module</strong> which can constantly check its status and its effects on the system.</p> <p>This project will implement <em>monitoring module</em>, which will be constantly reviewing <em>system resources</em> and <em> <strong>OWTF</strong> status</em>. <em>Health monitor</em> will be completely detached from <strong>OWTF</strong> and will interact using the ReST API. It will ensure a method to overcome the situation and the alert to the user when threshold value is reached. It will take necessary decisions based on the configurations set by the user/default.The module will have a <em>console</em> and <em>web UI</em> to monitor and configure the module.</p>

While Open Library excels at patron aquisition, it struggles with retaining the patrons- this happens due to a break in flow as post sign up patrons are met with an empty dashboard and lack of personalization. Without clear guidance, patrons struggle to find 'What to do next?' and drop off without engaging with the library or features such as reading lists and social connections. This project aims to bridge that very gap between 15 million patrons and 40 million works by introducing a progressive onboarding flow and a highly personalized dashboard for its patrons. By capturing user preference on sign up, we can personalize their dashboard ridding of the empty experience and providing clear Next steps, along with redesign of the dashboard to emphasize the high value features. Deliverables: Progressive Onboarding Flow (A 3-part form that captures and stores broad patron taste, specific book taste and yearly reading goal), Personalized Dashboard (Overhaul of the present 'My Books' page to priortize high-value features and addition of the 'Next reads' system), and the Recommendation Engine that powers the 'Next Reads' components using existing solr infrastructure.

The GA4GH Service Info API is a required component across standards such as TES, WES, and TRS, providing essential metadata about a service. Currently, each implementation must manually develop and maintain its own /service-info endpoint, leading to duplication, inconsistent metadata, and difficulty in supporting new capabilities such as security and extensibility features. This project proposes a reusable GA4GH ServiceInfo Sidecar a lightweight proxy service that runs alongside existing GA4GH services and handles /service-info requests centrally, while forwarding all other requests transparently to the backend. The sidecar will generate standard-compliant responses using a combination of static configuration (config.yaml) and dynamic metadata collected through a plugin system, enabling seamless support for service-specific and custom extensions without modifying backend code. The project will deliver a production-ready implementation with schema validation, extensibility aligned with GA4GH specifications, and deployment support via Docker and Kubernetes. Additionally, the sidecar will support Trusted Execution Environments (TEE) by advertising attestation capabilities via the ServiceInfo API and delivering attestation reports through a dedicated endpoint, enabling verifiable trust without implementing low-level attestation logic.

<p>A MPD module is to be developed as a control module inside VLC. It should handle requests from any mpc-client. Implementation of MPC Protocol and features, based on a client-server architecture. Linking the module to the media library to play media files on systems connected to the server.</p>