Goal: Standardize idempotency enforcement to prevent replay attacks in core financial modules. Implementation Strategy (Addressing James Dailey's feedback):

1. Opt-In Architecture: New logic will be behind a Global Configuration flag. Default remains legacy behavior to ensure 100% backward compatibility.

1. Phased Approach: Audit existing m_portfolio_command_source usage and bridge gaps in the Savings module first.

1. Testing: Implementation of integration tests simulating network failures/retries.

As requested by James Dailey on the mailing list, add the Digital Public Goods (DPG) badge to the project website and the main repository README following the DPG Alliance usage guidelines.

As requested by James Dailey on the mailing list, add the Digital Public Goods (DPG) badge to the project website and the main repository README following the DPG Alliance usage guidelines.

NuttX is very Unix/Linux-like RTOS for microcontrollers and it supports dynamic loading of binaries and libraries. It makes perfect sense to have the possibilities to create

NuttX is very Unix/Linux-like RTOS for microcontrollers and it supports dynamic loading of binaries and libraries. It makes perfect sense to have the possibilities to create a NuttX Distros similar to what exists for Linux.

In fact there is already a proposal here: https://github.com/apache/nuttx/issues/17351

Goals:

1) Test ELF Loading in the current NuttX mainline
2) Create an application that will be downloaded and updated the existing version on the board
3) Add Library support on NuttX/NuttX-Apps (use Android Makefile Library building as reference)
 

Background

Apache Wayang is a cross-platform data processing framework that lets enables users to write data analytics tasks once and execute them efficiently across diverse multiple heterogeneous execution engines such as Apache (e.g., Spark, Apache Flink, relational databasesJava Streams, and others. It abstracts heterogeneous backends and can enable efficient hybrid execution across different execution engines). In addition, Wayang optimizes execution plans across platforms and can split pipelines to be executed among multiple backends to optimize performance.

Currently, Wayang supports dataflow-style APIs in Java, Scala, and Python and an SQL API. However, there is no high-level DataFrame API — a programmatic abstraction widely used in modern data processing ecosystems (e.g., Spark DataFrames, Pandas, R DataFrames) — that lets users express relational transformations over structured datasets in a fluent, tabular style.

A DataFrame API for Wayang would dramatically improve usability for data engineers and scientists, making Wayang accessible to users familiar with DataFrame programming paradigms while preserving its powerful cross-platform optimization capabilities.

Project Goal

Implement a DataFrame API for Apache Wayang that:

• Represents structured data in a tabular abstraction (rows & columns),

• Supports common relational and analytical operations (select, filter, join, groupBy, aggregate, etc.),

• Can compile DataFrame operations into Wayang plans executed across backends transparently,

• Includes comprehensive documentation and examples.

Outcomes & Impact

By the end of GSoC, Wayang will have its first robust DataFrame API — a major usability milestone that bridges structured analytics with cross-platform execution. This will enhance adoption, unlock new classes of applications, and position Wayang as a friendly high-level programming environment in addition to its optimizer backend strengths.

provides programmatic APIs (Java/Scala) and SQL support. However, it does not expose a standard JDBC interface that would allow external tools to connect to Wayang as if it were a relational database.

Many analytics tools rely on JDBC to communicate with query engines. Implementing a JDBC driver for Wayang would allow users to issue SQL queries to Wayang using standard database tooling.

Project Goal

Design and implement a JDBC driver for Apache Wayang that allows users to:

• Establish a JDBC connection to a Wayang instance,

• Submit SQL queries via standard JDBC interfaces,

• Retrieve results using ResultSet,

• Access metadata through DatabaseMetaData,

• Integrate Wayang with existing SQL-based tools and BI platforms.

The driver should delegate incoming SQL queries to the SQL api provided by Wayang. 

Difficulty: Minor
Project size: ~90 hours (smallDifficulty: Medium
Project size: ~350 hours (Large)
Potential mentors:

• Zoi Kaoudi — zkaoudi zoka (at) apache.org

Background

Apache Wayang is a cross-platform data processing framework that enables allows users to write data analytics tasks once and execute them execute analytics pipelines across multiple heterogeneous execution engines (e.g., such as Apache Spark, Apache Flink, Java Streams, and others). In addition, Wayang optimizes execution plans across platforms and can split pipelines to be executed among multiple backends to optimize performance.

Currently, Wayang provides programmatic APIs (Java/Scala) and SQL support. However, it does not expose a standard JDBC interface that would allow external tools to connect to Wayang as if it were a relational database.

relational database systems. Wayang’s optimizer automatically selects where to execute a pipeline and enables hybrid pipelines where part of it can be executed in one platform and part of it in another.

Wayang’s architecture is built around a pluggable backend model. Each execution engine is integrated via a dedicated backend implementation that translates Wayang’s logical operators into engine-specific physical operators.

Current execution engines (platforms) that Wayang supports include: JDBC-based databases, Spark, Flink, Tensorflow, Giraph. Many analytics tools rely on JDBC to communicate with query engines. Implementing a JDBC driver for Wayang would allow users to issue SQL queries to Wayang using standard database tooling.

Project Goal

Design and implement a JDBC driver for Apache Wayang that allows users to:

• Establish a JDBC connection to a Wayang instance,

• Submit SQL queries via standard JDBC interfaces,

• Retrieve results using ResultSet,

• Access metadata through DatabaseMetaData,

• Integrate Wayang with existing SQL-based tools and BI platforms.

The driver should delegate incoming SQL queries to the SQL api provided by Wayang. 

one or more new execution engine backends to enable Apache Wayang to work in data lake environments.

Potential target engines include (depending on feasibility and community discussion):

• Apache Datafusion

• Trino / Presto

• Dremio
• BigQuery

The project includes:

• Implementing the backend abstraction layer,

• Mapping Wayang logical operators to the new engine’s execution model,

• Integrating cost estimation for the optimizer.

Difficulty: Medium
Project size: Depends on the number of platforms. It can be 175 (medium) or ~350 hours (largeDifficulty: Minor
Project size: ~90 hours (small)
Potential mentors:

• Zoi Kaoudi — zoka — zkaoudi (at) apache.org

• Juri Petersen — juri (at) apache.org
• Community — dev (at) wayang.apache.org