Explore Projects

This task focuses on bringing binary diffing directly into Cutter by integrating the core capabilities of rz-diff into its interface. Since binary diffing is a common reverse engineering workflow, the goal is to let users select and compare two binaries within Cutter itself rather than relying on external tools. The project would involve building a user-friendly file selection interface for choosing the binaries to compare, then visually presenting detected differences across Cutter’s major analysis views, including the hexadecimal view, disassembly view, graph view, and pseudocode view, so analysts can inspect structural and behavioral changes seamlessly in one environment.

<p>Metal Renegades originally started as an idea on the MovingBlocks forum for a brand new gameplay module for use the Terasology engine. The new game would be an open-world sandbox, where the player is dropped into a futuristic western world populated by robots. The core gameplay would be driven by faction conflict, building mechanical systems, advanced NPC interaction, resource gathering, and much more. This project takes some of the first steps to start bringing the ideas mentioned in the post to life. Specifically, this project focuses on the underlying world of Metal Renegades, and the interactions of AI agents that populate it. This world provides a strong backbone to build the core gameplay elements upon.</p>

<p>BCC (BPF Compiler Collection) is a toolkit for efficient kernel tracing using eBPF (extended Berkeley Packet Filters). This project extends the current PCP BCC PMDA (Performance Metrics Domain Agent) by adding advanced BCC tools for system introspection and extends Vector with new widgets that expose these collected metrics. The collected metrics include block device I/O latency, latency of the open/read/write/fsync operations for ext4, xfs and zfs, per-process disk I/O time, TCP session and retransmit details, per-process TCP throughput, scheduler run queue latency and process details of new processes.</p>

<p>The current GNSS-SDR platform is a software defined receiver that supports GPS, GLONASS, and GALILEO GNSS signals. It also partially supports Beidou signals, but this is limited to the Beidou B1l signal. This proposal will expand the software receiver to accommodate acquisition and tracking of Beidou B2a signals that would further expand the receiver's capabilities in facilitating research on multi-constellation and multi-frequency receivers working with real signals. In addition, the demodulation of the navigation messages will open the door to innovation in multi-constellation receivers, addressing topics such as integrity, reliability, robustness, enhanced coverage, and high-accuracy positioning. Furthermore, the integration of Beidou observables into the position velocity time solution will allow the achievement of the aforementioned diverse range of applications and components.</p>

<p>With Global Navigation Satellite System (GNSS) being popular in position-based applications with high accuracy, our growing dependence on GNSS within critical infrastructures has posed some concerns about the potential threats to GNSS. While GNSS can provide us precise positions estimation, the GNSS signal can be easily affected by some error sources, for example, jamming signal in this project. In this project, our main hypothesis is that jamming signals can be considered as outliers (either in time of frequency domain) to the received GNSS signal. To mitigate those outliers, robust version of cross-ambiguity functions (CAFs) are introduced with Maximum Likelihood (ML) estimator under heavy tailed distribution and M-estimator. Thus we can reduce the affect of jamming signals in terms of outliers and make GNSS more robust.</p>

<p>Fedora IoT effort is the latest of Fedora’s objectives. Its goal is to “create a Fedora Edition for Internet of Things, which will make Fedora the default for open source innovation on IoT hardware, middleware and backend platforms”. Many IoT devices have special requirements for operation and automation. Among these is the requirement to not break upon operating system upgrades. As part of Fedora IoT, Peter Robinson ideated the Atomic Host Upgrade Daemon, which builds on the Atomic Project and rpm-ostree, a project also labeled “Git for Operating Systems”. This monitoring daemon will re-use the work done for Atomic Updates for IoT system, allowing for automatic checking for available upgrades, applying them, rebooting, checking the system status and, in case of errors, rolling back the changes.</p>

<p>Boost.uBLAS employs numerous compile-time optimizations which improve the performance of matrix operations. However, there is no implementation of any application on matrices which can exploit this performance - like mean, variance, factorization etc. Providing some such fundamental functionalities for vectors and matrices in a single package would be a great addition to the uBLAS library. The goal of this project is to lay out the foundation of uBLAS to support basic statistical analysis methods and machine learning algorithms. More specifically, I am interested in implementing the following fundamental components:</p> <ul> <li>Basic statistics</li> <li>Running statistics</li> <li>Histograms - with custom number of bins and edges</li> <li>KMeans clustering</li> <li>Principal Component Analysis (PCA)</li> <li>Gaussian Mixture Model - Expectation Maximization</li> </ul>

<p>This project concerns the enhancement of the material design UI. With this GSoC program, I would like to complete some functionalities to make radare2 more user-friendly with a smoother learning curve. This UI will enable users to use the radare2 framework through any devices from smartphone, tablet or PC with a modern responsive interface that can be used easily by novices or pro-users. The functionalities developed concerns search functions, the improvement of the several tools (hexdump, disasm...) and the development of the graph module with a new library with the ability to have more representations. This project will also permit the usage of the T command of r2 binary to send and read messages through the UI. In the same way, the scripting area that allows the user to make some automation will be improved to be more friendly and authorize new usages. In resume, this work will allow to improve drastically the comfort in the use of r2.</p>

Currently there are two ways of replication filters in MariaDB. One method filters data on the primary node by not writing unwanted events to the binary log, However, this approach risks losing important data and can cause issues with point-in-time recovery. The alternative is to send all data from the primary node to the replicas and let them filter out what they don't need although this method not only increases network traffic and resource usage but also creates a risk of inconsistent data if replicas are misconfigured. This proposal suggests adding a filter on the primary node that checks which data should be sent to the replicas, while still logging all events in the binary log. The filter will help control what gets replicated without affecting the ability to recover data. This would lead to less network bandwidth being used, less work needed on the replicas, and more consistent replicas by applying the same filtering rules in one place (primary filter instead of replica filter).

The aim of this project is to add support for an LLM (large language model) based on tools such as GPT-4 to support AI-based programming support for our users. This support could range from proposing code from text prompts, help in correcting bugs or other issues, finding a good architecture or meaningful names, writing Catrobat language tests for one's code, proposing extensions, proposing project ideas, explaining downloaded code, providing translations of variable or message names etc from downloaded projects of other users, proposing image and sound resources based on the context and text prompts, explaining basic or more advanced concepts needed to realize projects, e.g., simple concepts such as variables and loops, or more complex ones such as software design patterns or testing strategies. Overall, the proposed project aims to provide a more comprehensive and tailored solution for Catrobat users, with a broader range of features and a more user-friendly interface compared to existing products.

This project involves working with Capa, a tool which detects capabilities in executable files. The rationale behind the project is that, current static analysis tools often struggle with scripting languages because of its reliance on fragile regular expressions that can be easily evaded . So, this project aims to extend the capa engine to natively support the static analysis of scripting languages using Tree-sitter. I plan to solve it by working towards the merging the tree-sitter implementation pull request. Once it is merged, I plan to extend the tree-sitter to support more languages of which Bash and Powershell are in my priority list. Then, I will extend the feature extraction of the tree-sitter to have more detailed analysis. Next, I plan to write the capa rules which would verify the integration. Also, I will add relevant documentation for ease of developers and contributors. I plan to deliver all the goals mentioned above within the 12 weeks timeline. Beyond GSoC, I plan to stay involved by contributing code, reviewing pull requests and participating in community discussions.

<p>My objective for the Google Summer of Code (GSoC) 2018 is to develop a Graphical User Interface (GUI) to monitor the GNSS-SDR status complying with all the requirements specified in the project idea. Among the most relevant are: user-friendliness, non-intrusiveness with the receiver core functionality, able to work in real-time and the ability of running either locally or remotely as a standalone application in Windows, Linux and macOS.</p> <p>Development of the GUI will be done using the C++ Qt 5 framework. The communication mechanism between GNSS-SDR and the GUI will be implemented using the Boost Serialization libraries.</p> <p>Considering the complexity of this project, all the phases of the software development life cycle will be addressed. This includes: requirement analysis, design, implementation, testing and maintenance. Moreover, the associated documentation will be written, as it is an essential part of any high-quality software engineering project.</p> <p>This GUI will bring the end user a greater control and awareness over GNSS-SDR.</p>

<p>The current version of GNSS-SDR supports GPS, GALILEO, GLONASS and BeiDou Global Navigation Satellite System signals. Right now in BeiDou signals, GNSS-SDR fully supports BeiDou B1l and BeiDou B3I. The primary goal of this project is to make the software receiver compatible with the BEIDOU B1C signals. This project will enhance the software receiver to aid acquisition and tracking of BEIDOU B1C signals that would further expand the receiver's capabilities and would facilitate research on multi-constellation, multi-frequency receiver working with real signals. The demodulation of the B-CNAV1 navigation message of BEIDOU B1C will open the door to innovation in multi-constellation receivers. Along with the fully functional implementation of a GNSS receiver working with BEIDOU B1C signals, this project will help to address topics such as integrity, reliability, robustness, enhanced coverage, and high-accuracy positioning. Additionally, the integration of BEIDOU B1C observables into the position, velocity, time (PVT) solutions will allow the achievement in a diverse range of applications and components.</p>

This project aims to implement the ANY_VALUE() and GROUPING() functions in MariaDB, addressing longstanding gaps in compatibility with MySQL 8.0 and modern SQL standards. Currently, the absence of these functions limits MariaDB’s usability in applications that rely on advanced GROUP BY semantics, particularly when migrating from MySQL or working with rollup queries. To solve this, I will extend MariaDB’s SQL parser and execution engine to support both functions. For ANY_VALUE(), I will implement a new aggregate function that allows safe selection of non-aggregated columns under ONLY_FULL_GROUP_BY. For GROUPING(), I will introduce a function that distinguishes between NULL values originating from rollup aggregation and those present in the underlying data, by tracking rollup state during query execution. The primary deliverables of this project include fully functional implementations of ANY_VALUE() and GROUPING() in MariaDB, comprehensive MTR test suites validating correctness and MySQL compatibility, and updated documentation describing their usage and behavior. The final outcome will improve MariaDB’s standards compliance and provide developers with essential tools for writing expressive and portable SQL queries.

MariaDB's HNSW vector index searches the graph layer by layer, isolating each level's connections. This means denser lower-layer edges are invisible until a separate pass reaches them, and the purely flat alternative, which expands all layers unconditionally, wastes distance computations on unproductive regions, degrading performance. Solution: Implement VF-HNSW (Virtually Flattened HNSW), a new search mode for MariaDB's vector search engine. VF-HNSW searches all layers in a single pass with adaptive descent: for each candidate, it expands neighbors from the top layer downward, using sparse upper layers as cheap probes and stopping early when a layer fails to improve on the one above, avoiding expensive dense-layer expansion for candidates in unproductive regions. Deliverables: A vf_hnsw search mode in sql/vector_mhnsw.cc with adaptive descent, including correctness and regression tests. A benchmark report comparing hierarchical, flat, and VF-HNSW across ANN-Benchmarks datasets, with recommended defaults and tradeoff analysis. Per-query status variables expose upper-layer expansions attempted, layers skipped, and distance computations saved.

CAPA is the FLARE team’s open-source tool to identify program capabilities using an extensible rule set. Each rule is matched against features that CAPA extracts from a program. Extracted features include file-level features such as strings, section names, imports, and exports and function-level features such as API calls, string and byte references, instruction mnemonics, and number constants. CAPA uses feature extractors, called "backends", to extract features from supported file types (PE, ELF, and .NET) and architectures (32- and 64-bit x86). Each backend is built around an existing tool or library that provides file parsing and disassembly capabilities. CAPA uses this to extract features. CAPA currently implements backends using Vivisect, IDA Pro, and dnfile. Ghidra is a popular open-source disassembly framework with a robust API to access its analysis. Programs can interact with a wealth of information that includes parsed file formats and disassembled code. The goal of this project is to develop a Ghidra backend for CAPA using Python 3 (via Ghidrathon) and Ghidra’s scripting API. Users should be able to invoke CAPA such that it uses Ghidra’s analysis engine and/or invoke CAPA from within Ghidra.

<p>Currently, there are no heap-specific widgets in Cutter to get information about the heap while debugging a program. This project aims to solve this by providing various heap visualization widgets and memory maps to provide information about the state of the heap. Another issue with the heap parsing in Rizin is that it depends on how Rizin is compiled and fails for cases of non-native and remote debugging cases. The project will also try to expand the number of heap allocators that Rizin supports. After completing this project, users would be able to get information about the state of the heap in Cutter and do this for cases of remote debugging and a variety of allocators. As part of the project, the following are the key features that will be added and changed:</p> <ul> <li>Widgets in Cutter for the following:</li> <li>Bins Info (Fastbins, Unsorted, Small, Large)</li> <li>T-cache Info for each thread</li> <li>Arenas Info (chunks, top, last remainder)</li> <li>Graph visualization for bins and tcache</li> <li>Improve the implementation of heap related commands like <code>dmh</code> in Rizin</li> <li>Refactor the Rizin code to make heap parsing work for non-native code</li> <li>Add heap parsing for other allocators like MacHeap.</li> </ul>

Problem: Qdrant, a vector search engine used for similarity search and clustering, lacks the necessary functionality to effectively visualize and explore vector data. This results in users relying on external tools or code to analyze and visualize their data, which can be time-consuming and require specialized knowledge. Thus, there is a critical gap in the platform's functionality that needs to be addressed. Solution: To address this issue, a web-based user interface will be developed that will provide l an accessible and user-friendly platform for users to interact with and explore their vector data. This tool will allow users to quickly visualize their data, perform exploratory data analysis, and gain insights into their data without relying on external code. Additionally, a web-based interface will be more accessible to a broader range of users, including those without advanced programming or data analysis skills. Deliverables: The proposed project aims to create a user-friendly web application with a comprehensive set of tools for managing and analyzing data. The application will be visually appealing, easy to use, and accessible on multiple devices. Documentation will also be provided to ensure ease of use and further development. The final deliverables will include a functional and deployable web-based UI for Qdrant that addresses the critical gap in the platform's functionality, making it more accessible, user-friendly, and practical for a wider range of users.

The main goal of this project, is to implement in a sofware-defined GNSS receiver (GNSS SDR), EGNOS/WAAS signals. They are both satellite-based augmentation systems (SBAS) that enhance the accuracy and reliability of GNSS. One of the main advantage is the improvement of vertical and horizontal accuracy. By developing acquisition and tracking blocks to capture these signals, precise positioning and advanced research on the ionosphere could be enhanced. As a user with a year of experience using GNSS-SDR and GNURadio, the process of developing the required solution will be carry out in a better way. The expected time to complete the project is 350h, which can be splitted in these deliverable groups: 1.- 50h: acquiring information about the problem and studying the way acquisition and tracking blocks work in GNSS-SDR. The type of signals, the way to decode messages and their structure, should be well understood before starting coding the solution. The proposed deliverable is a short presentation, in order to show this information to the mentors and after that, proceed with the coding. 2.- 250h: the main block of the project. During this period, the solution has to be created in C++. The different processing blocks (acquisition, tracking, observables and PVT) must work at the end of the period for SBAS signals. The proposed deliverables are tracking and acquisition blocks working after the first 150h, and then the integration with the observables and PVT has to be demonstrated. 3.- To conclude, the last 50h of project are dedicated to develop tests to demonstrate the robustness of the solution and to implement the code for real-time signals.

While Meshery's AWS model catalog contains auto-generated connections for individual services, it currently lacks the critical "cross-model" architectural relationships (like linking an EKS Cluster to EC2 Subnets, or an API Gateway to a Lambda Function) that Site Reliability Engineers need to properly visualize and manage real-world, multi-service cloud deployments on Kanvas. Solution: This project systematically defines these missing inter-model dependencies by combining deep AWS architectural expertise with Meshery's v1alpha3 relationship schema. This involves mapping complex multi-hop infrastructures and accurately structuring evaluation queries, metadata, and mutatorRef/mutatedRef patch paths. Deliverables: 1. A comprehensive audit of cross-model gaps in the current AWS catalog. Implementation of high-priority infrastructural relationships (Networking, IAM Permissions, Firewalls). 2. Definition of complex multi-hop chains (e.g., end-to-end Serverless Event Pipelines, EKS Full Stack dependencies). Visual validation of all new relationships within Kanvas and detailed contributor documentation to guide future model integrations. 3. Definition of complex multi-hop chains (e.g., end-to-end Serverless Event Pipelines, EKS Full Stack dependencies). 4. Visual validation of all new relationships within Kanvas and detailed contributor documentation to guide future model integrations.

<p>Redesign and Implement the DroLa system as a real time database based system instead of WebSocket based system. Introduced bi-directional end-to-end secured communication between sensor nodes and Application Server. A new packet structure with the binary level message header, header parser and message parsers to make the system more general to use as a general tracking system.</p>

In a previous LFX mentorship project (https://github.com/WasmEdge/WasmEdge/issues/3495), we have created an LLM-based coding assistant grounded in Rust programming language skills (https://huggingface.co/datasets/gaianet/learn-rust). We aim to further improve the Rust coding assistant by incorporating inference-time compute that utilizes the Rust compiler for feedback. One of the greatest advantages of Rust is its powerful and strict compiler, and the detailed error message generated by the compiler. The Rust compiler could give valuable feedbacks to code generating LLMs to improve the code quality. Expected Outcome: 1. Run a Qwen Coder 2.5 LLM locally (https://github.com/GaiaNet-AI/node-configs/tree/main/qwen-2.5-coder-7b-instruct) or access it via an API. 2. Create an LLM system prompt that describes the structure and key elements of a cargo project. It will guide the LLM to generate multiple files (artifacts) for a complete project. 3. Create a Python program to send user requests to the LLM and parse the generated result into locally cached files. 4. Use a local Rust compiler to build the generated project. Sends the error messages back to the LLM to re-generate. 5. Iterate until there is no more errors. 6. Build a web API for the Python program that takes OpenAI compatible requests and return OpenAI compatible results.

<p>An emulation engine for Azure services to try out in local environment</p>