Google Summer of Code 2025 proposed ideas

Contributors interested to participate should check which of the following projects fits their interests and skills.

Τo communicate with the mentors and ask questions about the projects, students should subscribe to this list and post relevant questions. Please follow the Proposal Template

For practical information, developers should visit this page.

🇬🇷 Making LLMs Talk Greek 🇬🇷

Brief Explanation

GlossAPI is an open source project seeking to develop a standard open access corpus of the Greek language, and benchmark it against existing and to-be-developed language models, with the objective of providing an upstream service to the Greek tech community. The project is named after a portmandeau of the Greek word for "language" and "API" which creates a visual resemblance to the word Glossary in Greek. This is to express our objective to provide an index of the Greek language via flexible programing interfaces.

Greek is a language that is under-represented in existing LLMs, while it has a complex history, grammar and writing system. Our trials with existing models have shown lack of syntactic and semantic knowledge of advanced Greek and its nuances, and we have put forth a number of analyses showing that this poses a risk for digital divides, language extinction, and subpar experience for users of public services.

To our knowledge other LLM projects that tackle the problem of the Greek language are either proprietary, closed code, narrow scope, or otherwise unfit for our purpose which is to provide publicly available, fully open source language models with respect to all code/weights/procedures/data. We reach out and bring together people that have the expertise, the passion, the collections, or the hardware, to take part in this endeavor, that will help the Greek stratup/tech scene catch up with the rapid developments in downstream applications that are now common place for developers of English language generative models.

Expected Results

The project will result to an Open Source Corpus, representative of the Greek language and its different varieties. At first emphasis will be given to the formal varieties used in government, education and the law. Additionally, we want to represent, in a subsequent training stage, a number of basic knowledge domains to an "undergraduate degree" level. The datasets will be versioned and benchmarked against different models and tokenizers. We also need to develop a sufficient set of evaluation tasks (such as Factual QA - Greek). Finally a couple of foundation models of different architectures will be fitted onto the dataset and the evaluation suite, and published to the community under an open source licence. With these moves we expect to pollinate the Greek tech ecosystem with reliable, inexpensive, and extensible models and datasets, that will help the Greek Open Source AI scence thrive. All data and models will be accompanied by thorough documentation and guides, to ensure replicability and reusability of the results.

Duration of the Project

350 hrs

Related Repositories

https://github.com/eellak/glossAPI/ https://github.com/eellak/glossAPI/wiki

Knowledge Prerequisites

Corpus Annotation for Language Models Quantitative Corpus Linguistics or Natural Language Processing Python with transformers library, sci-kit learn, numpy, pandas and streamlit, langchain or similar Mathematical statistics or similar discipline Django knowledge is good to have

Mentors

F.Karounos, A. Melidis, Greek Free Open Source Software/Hardware Alliance

Expanding HassIO smart home capabilities via low-code automation development

Brief Explanation

Smart environments are becoming quite popular in the home setting consisting of a broad range of connected devices. While offering a novel set of possibilities, this also contributes to the complexity of the environment, posing new challenges to allowing the full potential of a sensorized home to be made available to users. SmAuto, is a Domain Specific Language (DSL) that enables users to program complex automation scenarios and pipelines, for connected IoT devices in smart environments, that go beyond simple tasks. It was initially developed by the ISSEL research team (AUTH) as textual DSL and later evolved into a web-based low-code development environment. SmAuto lacks extra features like utilization of external REST data sources, time delays, semantic annotation, and accessing of in-house entities, etc., thus it should be expanded in this direction. Furthermore, HomeAssistant would benefit from the integration of a low-code approach for rapidly developing and deploying automations, using the entities existing in a smart environment.

Expected Results

• In the context of this project, we desire to expand the SmAuto DSL with the following features: a) support the REST protocol, so as for the automations to be able to access information from external data sources, b) incorporate auxiliary concepts like Delay, Switches, or Compute nodes, c) SmAuto integration in HA. The integration of SmAuto and HomeAssistant should occur, by creating a new open-source HA addon, where users will be able to design and deploy automations graphically, using the SmAuto low-code environment.

Duration of the Project

(350 hours).

Related repositories

https://github.com/robotics-4-all/smauto, https://www.home-assistant.io/

Knowledge Prerequisites

[Required]: Python, Software engineering, IoT concepts, Unix/Linux, [Desired]: Model Driven Engineering, HomeAssistant, Docker

Mentors

Konstantinos Panayiotou, Emmanouil Tsardoulias, Andreas Symeonidis

A Tool for Visualizing the Arguments, Sentiments and User Interactions of Online Discussions

Brief Explanation

In recent years, the analysis and visualization of dialogue have gained prominence in fields such as computational linguistics, social sciences, and human-computer interaction. The ability to model, analyze, and visualize real-life discussions provides valuable insights into the flow of conversations, the exchange of arguments, and the sentiments conveyed. Such visualizations can improve the understanding of complex discussions, foster decision-making, and even help develop better AI systems for facilitating or mediating discussions. We are particularly interested in online text-only discussions (e.g. on platforms like Reddit).

Various tools and platforms have been developed in order to facilitate structured discussions and multi-party decision making. Kialo is an online, structured debate platform, where the use of argumentation is the central component. It allows the construction of argument maps, in the form of trees. It promotes thoughtful discussion, understanding of different viewpoints and collaborative decision-making, through visualizations of argument maps.

Debategraph is another online structured debate platform, using more complex graphs, called "mind-maps", where arguments are interconnected in a web-like structure. It allows an even wider choice of visualizations of relationships between ideas.

DebateVis is a tool that can help non-expert users explore and analyze debate transcripts. Given a transcript, the tool produces: (a) an Interactions Graph that summarizes how often each candidate spoke overall, mentioned other candidates and discussed each topic, (b) an Annotated Transcript with automatically extracted topic labels and speaker interactions, (c) a Timeline visualization providing an overview of the debate.

Finally, VisArgue is a framework proposing a range of visualizations of dialogues, including: Lexical Episode Plots (a timeline representation of the topics discussed), (b) Conversational Topic Visualizations, representing the shifting of focus of individual user on topics, (c) various statistics measuring user participation, respect, justification and accommodation, (d) Lexical Units, which are timeline representations of features such as the amount of argumentation and emotions.

Although tools such as the above offer important functionality, there are still issues: in most cases, either the source code is not available, or integration with new projects is not seamless, or it is difficult to parameterize the output. Furthermore, the tools above focus mostly on debate, whereas we are also interested in other types of online discussions (e.g. deliberation to improve legislation bills, non-adversarial discussions for intra-company decision making).

Therefore, this project’s goal is the design and implementation of an open source tool for visualizing and analyzing real-life, online, text-only discussions, exploring subjects like: topics discussed, arguments exchanged and emotions conveyed. The project will also explore how these visualizations can be leveraged for improving public understanding of contentious issues, academic discourse, and online discussion platforms.

Project Objectives / Contributions:

- Select, from the literature, prominent dialogue visualization approaches / ideas (e.g. styles of graph-based, or timeline-based, visualizations used) to represent various aspects of real-life online discussions and collect available libraries (not necessarily discussion-specific) that can be used to implement them (e.g. Gephi, NetworkX).

- Explore the open-source toolkits being developed in the Archimedes project “LLM3: LLMs as mediators and moderators” to measure dialogue quality aspects (e.g., sentiment, politeness, topics, user participation) and select those that can provide useful meta-data for visualizing on-line discussions.

- Develop a tool capable of ingesting data from real-life online discussions generating relevant meta-data (possibly by calling other toolkits) and producing the desired visualizations of the discussions.

- Potentially, evaluate the effectiveness of the tool and its visualizations in making complex online discussions understandable to diverse audiences, such as researchers, mediators, or general users.

Project Impact:

- A novel, easy-to-use, open source, visualization tool (with accompanying paper) for online, text-only discussions, that can help the analysis of discussions in different settings and domains (e.g. political discourse, academic debates, or customer feedback).

- Expand the general understanding of how visualization techniques can make debates more accessible and informative (possibly also leading to a publication).

  - Contribution to the Archimedes project “LLM3: LLMs as mediators and moderators” which aims to develop and evaluate LLM-based mediation agents that will actively participate in online discussions, with or without additional human mediation.

Key Types of Dialogue Visualizations:

The project will develop and explore several types of dialogue visualizations. Some are briefly described below. The contributor will be free to propose and implement new ones.

    1) Timelines: they represent the chronological flow of a conversation, highlighting key moments such as topic shifts, argument introductions and emotional peaks. Possible Features: topic evolution over time, points of conflict or agreement, visual markers for significant events (e.g. emotional outbursts or resolution points).

    2) Argumentation Graphs: they visualize the logical structure of arguments, including claims, counterclaims and evidence. Possible Features: nodes representing arguments or claims, edges denoting relationships (e.g., support, contradiction).

    3) User Interaction Graphs: they map the relationships and interaction patterns between participants in the debate. Possible Features: nodes representing participants, weighted edges showing the frequency, tone, or sentiment of interactions, clusters indicating subgroups or coalitions in the dialogue.

    4) Sentiment Heatmaps: they analyze and visualize the emotional dynamics of a conversation. Possible Features: color-coded intensity for positive, negative, or neutral sentiments, overlay with timeline or topic visualization for richer insights.

    5) Topic Trees or Topic Flow Diagrams: they represent how topics are introduced, branched out, and revisited during the discussion. Possible Features: hierarchical or radial layouts for topic relationships, highlights of overlapping or transitioning topics.

    6) Hybrid Visualizations: by combining multiple visualization techniques.

Importance of Dialogue Visualizations:

Dialogue visualizations, such as those presented above, can support:

- Topic Analysis: by identifying the main topics discussed and their transitions over time, and by highlighting overlapping topics and their importance to the dialogue.

- Argumentation Analysis: by understanding the logical flow of arguments, counterarguments, and evidence, and by identifying circular reasoning, weak arguments, or areas of agreement.

- Sentiment Analysis: by visualizing the emotional tone of the conversation and its impact on the debate, and by examining whether certain sentiments correlate with specific topics or arguments.

- Participant Dynamics: by mapping the influence and activity of each participant, and by analyzing interaction patterns (e.g., dominance, interruptions, alliances).

Methodology:

- Data Collection and Preparation:

The tool should be able to ingest data from various online debate platforms (e.g. Reddit, Kialo), from political debate transcripts, from academic discourse, as well as from debates among LLM-agents. Since the format of raw data may vary, we propose the use of the Convokit tool in order to homogenise and preprocess the data.

- Development of Visualization Prototypes:

Tools/Technologies: Python (matplotlib, seaborn, Plotly), D3.js for web-based visualizations, or tools like Gephi for network analysis. Use natural language processing (NLP) libraries (e.g., spaCy, Hugging Face Transformers) for topic modeling, sentiment analysis, and argument mining, along with tools being developed at the LLM3 project of Archimedes.

- User Feedback and Iterative Improvement:

Test the outputs (visualizations) with researchers, mediators, or other stakeholders. Refine designs based on usability feedback and task-specific performance.

Evaluation

If time allows, the contributor will contribute in evaluating the effectiveness of their dialogue visualizations, in the context of Archimedes’ LLM3 project, by using them for both real-life and LLM-generated dialogues. Their output will be measured on clarity, usability and informativeness.

Desired Profile:

We are looking for a contributor with the following characteristics:

- Good programming skills in Python (experience in network analysis and / or NLP is a plus).

- Experience (and interest for) coding visual representations of concepts with libraries such as: matplotlib, seaborn, Plotly, Gephi, D3.js.

- Interest in the subject of human interaction through dialogue (more specifically, on themes such as: argumentation, topic identification, sentiment analysis).

- A taste for concise, elegant and efficient solutions / visualizations.

The contributor will be mentored/supported by members of the LLM3 project, the broader NLP group of Archimedes (https://archimedesai.gr/en/), as well as the NLP Group (http://nlp.cs.aueb.gr/) of the Department of Informatics, Athens University of Economics and Business.

Conclusion:

This GSOC project aims to develop an open-source tool that will make complex, online discussions more understandable, insightful, and actionable. By capturing the topics, arguments, sentiments, and participant dynamics, it will offer a comprehensive approach to online dialogue visualization that can benefit multiple fields, from education to public policy.

Related repositories

https://sites.google.com/view/llm3/home

Expected Results

A tool able to process real-life, text-only dialogues and produce selected visualizations capturing their essential points.

Mentors

Dionysios Kontarinis (denniskont@gmail.com), Ion Androutsopoulos, Ioannis Pavlopoulos

PersonalAIs: Generative AI Agent for Personalized Music Recommendations

Brief Explanation

This project aims to develop an AI-powered agent that interacts with users in natural language to determine their emotional state and musical preferences in a conversational manner. The agent will then generate and refine music playlists accordingly. The system will integrate with the Spotify API to provide personalized recommendations based on user preferences, liked songs, and listening history. Users can opt-out of personal data usage for a more exploratory approach. The agent will also enable real-time conversational modifications to playlists, allowing users to tweak mood, energy, and genre preferences.

Core Features & Technologies:

- Natural Language Processing (NLP): Used to determine user mood and preferences based on conversation.

- Generative AI: Small LLM models hosted locally or accessed via an API key for dialogue generation.

- Spotify API Integration: Authentication, playlist management, retrieval of user metadata (liked songs, playlists, etc.).

- Frontend UI: A web-based chatbot interface similar to ChatGPT.

- Backend Processing: Handles AI model interactions, API requests, and user session management.

- Real-time Modifications: Users can refine recommendations by requesting changes in mood, genre, energy, etc.

Sources & References:

- Spotify API Documentation: https://developer.spotify.com/documentation/web-api/

Mood-Based Playlist Research:

- Generating personalized music playlists based on mood and listening data

- Moodify: Emotion recognition in songs for personalized recommendations

Example Datasets:

- Moodify Dataset (Spotify-based mood labels)

- Awesome Music Emotion Recognition (MER) Dataset Collection

Expected Results

''- A full-stack AI agent (local hosted and/or API Key) that generates personalized music playlists based on user input.  - Integration with Spotify API for user authentication, playlist creation, and retrieval of user metadata.  - Real-time, conversational playlist modifications through a chatbot-style UI.  - Advanced mood detection using NLP or audio analysis. Integration with external music recommendation sources.

Duration of the Project

(350 hours).

Knowledge Prerequisites

''- Basics of Machine Learning and NLP.  - Experience with pre-trained generative models (e.g., GPT, BERT) and recommendation systems.  - Familiarity with APIs, particularly Spotify API.  - Frontend/backend development experience for a chatbot-style UI.

Mentors

Giannis Prokopiou, Thanos Aidinis

OpenRF 3D

Brief Explanation

This project aims to bridge NVIDIA Sionna’s 6G simulation framework with Cesium’s 3D geospatial engine, enabling real-time, terrain-aware wireless network analysis. The student will develop a bidirectional WebSocket pipeline to dynamically stream Cesium’s elevation and 3D building data into Sionna, where channel models are enhanced to account for terrain-induced pathloss and urban blockages. Simultaneously, Sionna’s ray-traced outputs (e.g., signal strength, beamforming patterns) will be visualized in Cesium as interactive heatmaps and antenna coverage overlays. Key deliverables include a Python/JavaScript interface using Protocol Buffers for efficient data serialization, integration of 3GPP TR38.901 models with real-world terrain, and Jupyter notebooks demonstrating urban/rural 5G optimization.

Expected Results

By the end of GSoC, this project will deliver a fully functional bidirectional WebSocket pipeline that integrates NVIDIA Sionna’s 6G simulation framework with Cesium’s 3D geospatial engine, enabling real-time, terrain-aware wireless network analysis. The system will dynamically stream Cesium’s elevation and 3D building data into Sionna, enhancing 3GPP TR38.901 propagation models with terrain-induced pathloss and urban blockages. Simultaneously, Sionna’s ray-traced outputs (signal strength, beamforming patterns) will be visualized in Cesium as interactive heatmaps and antenna coverage overlays. The project will develop an optimized Python/JavaScript interface using Protocol Buffers, ensuring low-latency, high-performance data exchange between Cesium and Sionna. Additionally, Jupyter notebooks will demonstrate urban/rural 5G optimization, beamforming analysis, and comparative studies of RF propagation models. The final deliverables will include a fully documented API, setup guides, and tutorials, contributing to the NVIDIA Sionna and Cesium open-source communities. This integration will significantly improve realism in RF simulations, allowing for next-generation 6G research, network optimization, and smart city planning.

Duration of the Project

(350 hours).

Related repositories

https://github.com/NVlabs/sionna, https://github.com/CesiumGS/cesium

Knowledge Prerequisites

A developer with strong Python & JavaScript skills, and an understanding of real-time networking (WebSockets, Protobuf). Experience in wireless communications & 3D geospatial visualization, and prior exposure to Sionna, CesiumJS would be highly beneficial.

Mentors

Ilias Chrysovergis (https://www.linkedin.com/in/ilias-chrysovergis/), Iason Malkotsis (https://malkotsis.com/)

Exploring and Abstracting Triplestore Alternatives

Objective

The primary objective of this project is to explore, analyze, and abstract various triplestore alternatives. The project aims to provide young programmers with a comprehensive understanding of different back-end alternatives that allow for storing data in triple format, commonly known as triplestores.

Background

Triplestores are a type of database specialized in storing triples, a data structure for representing information in a subject-predicate-object format. They are crucial in semantic web technologies, such as RDF, SPARQL, and OWL. However, there are numerous triplestore alternatives available, each with its own strengths and weaknesses.

Project Description

This project will involve a detailed exploration of various triplestore alternatives. The participants will perform rudimentary tests and benchmarks on these alternatives to understand their performance, scalability, and other key features.

The ultimate goal is to develop a library that can act as an abstraction layer for these triplestore alternatives. This library will "hide" the underlying implementation, allowing developers to switch between different triplestores without changing their application code. This abstraction layer can be compared to a library abstracting various specific relational database management systems, all providing very similar functionality, like supporting SQL.

Methodology

Research: Identify and study various triplestore alternatives. Understand their architecture, features, and limitations.

Testing: Perform rudimentary tests and benchmarks on the identified triplestore alternatives.

Analysis: Analyze the test results to understand the performance and scalability of each alternative.

Development: Develop an abstraction layer that can interface with the various triplestore alternatives.

Documentation: Document the findings and the usage of the developed library.

Expected Outcome

By the end of the project, we expect to have a well-documented library that can act as an abstraction layer for various triplestore alternatives. This will provide developers with the flexibility to choose the most suitable triplestore for their specific needs without having to modify their application code.

Conclusion

This project will not only enhance the understanding of participants about triplestore alternatives but also equip them with the skills to develop an abstraction layer, thereby broadening their programming skills and knowledge.

Duration of the Project

Long (350 hours)

Related repositories

New project, no existing repo available.

Information links

- Triplestore - Triples - Query language

Knowledge Prerequisites

Python (mandatory). Other programming languages like C, Go, Rust, Java, might prove useful.

Flexible GovDoc Scanner

Brief Explanation

The goal of this project is to develop the Flex GovDoc Scanner, an application that leverages the Node.js stack, AI tools, and cloud services to transform public incorporation documents from Greece's business portal (ΓΕΜΗ, https://publicity.businessportal.gr/) into structured, searchable data. This project aims to facilitate access to essential company information, such as legal representatives, board members, and incorporation history, by offering advanced discovery capabilities through a REST service.

Project Overview:

- Crawl and Index Public Documents:

  Develop a robust crawling mechanism to gather all relevant PDF documents from the ΓΕΜΗ portal while ensuring compliance with legal standards.

- Extract and Structure Metadata:

  Utilize AI and OCR technologies to extract key metadata from these documents and store them in a structured format.

- REST Service for Metadata Search:

  Create an efficient REST API to provide users with search functionalities on the extracted metadata, enabling easy access and analysis.

Related repositories

https://github.com/flexivian/govdoc-scanner

Expected Outcome

''- Implement a nodejs application to Crawl and Index Public Documents, utilize an opensource DB optimized for documents - Enhance the application with AI and OCR capabilities to extract metadata from scanned documents - Implement a REST API using nodejs to provide users with search functionalities on the extracted metadata, enabling easy access and analysis.

Knowledge Prerequisites

nodejs, docker, git , AI concepts and tools, NLP, OCR, RESTful API design and implementation, Knowledge of databases (SQL or NoSQL)

Mentors:

iskitsas@gmail.com, vasilisnx@gmail.com

Extending the capabilities of OpenTRIM

Brief Explanation

OpenTRIM is a new open-source code for simulating the passage of energetic ions through materials and calculating the associated modifications and damage that they cause to the these materials. It is based on the kinetic Monte-Carlo method and employs the Binary Collision Approximation to describe the interaction between ions and target atoms. OpenTRIM comprises of a set of C++ libraries, a command line program for executing simulations in batch mode and a Qt-based graphical user interface that can be used to configure & run a simulation and evaluate the results. Currently, there are various parts of OpenTRIM where work is needed for improving and extending the capabilities of the code.

Expected Outcome

1. Extend the base C++ simulation code to include new capabilities for user-defined “tallies”, i.e., scoring tables where data from the simulation are extracted as a function of ion energy, position, direction or other possible optional variables.  2. Create a tool for 2D or 3D visualization of the simulated ion trajectories. 3. Write a number of example simulations, complete with the required input files and evaluation of the output results, which will become a part of the code documentation.

Duration of the Project

Depending on the proposal

Related repositories

https://github.com/ir2-lab/OpenTRIM

Knowledge Prerequisites

C++, Qt (optional), OpenGL (optional)

Mentors:

George Apostolopoulos (https://github.com/gapost), Michail Axiotis (https://github.com/psaxioti), Eleni Mitsi (https://github.com/elmitsi)

Cleaning of HPLT Greek v2 Dataset for GlossApi LLM

Brief Explanation

Cleanup of the Greek datasets at https://hplt-project.org/datasets/v2.0. The cleanup will be done with the help of the glossAPI team.

For methodology see https://huggingface.co/spaces/HuggingFaceFW/blogpost-fineweb-v1+.

Expected Outcome

The goal is to isolate from the html Greek text with normal grammar and complete sentences (not fragmented).

Duration of the Project

Depending on the proposal

Related repositories

https://github.com/eellak/glossapi

Knowledge Prerequisites

Python, βιβλιοθήκες NLP

Mentors:

Foivos Karounos, Nikolaos Vidras

Add SAML and OpenID Connect support to Consul Democracy

Brief Explanation

Consul Democracy is a web-based citizen participation tool written in Ruby, using the Ruby on Rails framework. Consul Democracy is licensed under the AGPL and its installations are decentralized, meaning there are more than 200 institutions across the world running their own independent server and using a custom version of Consul Democracy. Some of these institutions have authentication solutions based on either SAML or OpenID Connect; however, there's no built-in support for these authentication solutions in Consul Democracy, so each institution has to build their own.

In Ruby, the OmniAuth library provides a standard way to manage multi-provider authentication. Consul Democracy currently uses several Ruby gems, all based on OmniAuth, to provide authentication via Facebook, Google, Twitter/X and WordPress. There's been an attempt at providing SAML support using the omniauth-saml Ruby gem, but its development hasn't been finished due to the lack of a SAML platform to test against.

Consul Democracy also supports multitenancy, meaning the same application can be used to manage several institutions (with different domains or subdomains). For authentication using Facebook, Google, Twitter/X or WordPress, Consul Democracy provides the option to use the same configuration for each institution, to use different configurations for different institutions, or a mix of both (one default configuration which can be overwritten per institution).

The aim of this proposal is to provide generic SAML and OpenID Connect authentication solutions in Consul Democracy so a variety of institutions can easily integrate their existing authentication platform.

Expected Results.

* Make it possible to authenticate in Consul Democracy using a SAML service

* Make it possible to authenticate in Consul Democracy using an OpenID Connect service

* Both SAML and OpenID Connect solutions must allow different configurations for different institutions in a multitenant environment

* Both SAML and OpenID Connect solutions should be flexible enough so institutions don't have to change the source code in order to configure their service

* The source code of the SAML and OpenID Connect solutions should be similar to the source code of the existing Facebook, Google, Twitter/X and WordPress solutions

* Update the documentation with instructions on how to configure SAML and OpenID Connect

Duration of the Project

Medium Size 175 hrs

Related Repositories

https://github.com/consuldemocracy/consuldemocracy

Knowledge Prerequisites

* SAML and OpenID Connect authentication configuration * (Optional) Ruby on Rails and OmniAuth authentication

Mentors

Javier Martín - https://github.com/javierm, Sebastià Roig - https://github.com/taitus

Docker for Consul Democracy citizen participation platform

Brief Explanation

Consul Democracy is a web-based citizen participation tool written in Ruby, using the Ruby on Rails framework. Consul Democracy is licensed under the AGPL and its installations are decentralized, meaning there are more than 200 institutions across the world running their own independent server and using a custom version of Consul Democracy. That means Consul Democracy developers don't have access to production machines, and so Consul Democracy must be as simple to install and maintain as possible so anyone can do it no matter how familiar they are with the technologies used by Consul Democracy.

Currently, Consul Democracy is installed on production by running an ansible-based installer which installs all the project dependencies on a Debian GNU/Linux or Ubuntu Linux server. Deployment of new developments is then done using Capistrano.

The source code of Consul Democracy contains a Dockerfile and a docker-compose.yml file that are exclusively meant for the development environment, in order to make it easier for developers who are familiar with Docker to contribute to the project. However, there's currently no way to deploy to a production environment using Docker, which is inconvenient for institutions who don't use Debian or Ubuntu on their servers, or for institutions who have adopted Docker as their preferred way to setup their servers. The main goal of this proposal is to solve this issue. Since 2024, Ruby on Rails applications are configured to use Kamal by default as a solution to deploy to production using a Docker container. To our knowledge, this would be the most simple solution to our problem.

There's a third kind of Docker integration, which uses a devcontainer to allow developers to use tools like GitHub Codespaces to run the application in a development environment, which is also configured by default in new Rails applications since 2024, and we'd like to enable this option in Consul Democracy.

With this developments, we could enable many more municipalities to utilise digital citizen participation - and thus offer their citizens greater involvement in the development of their cities.

Expected Results.

* Make it possible to install and deploy Consul Democracy applications using Docker in the most simple way (probably with Kamal)

* Add a devcontainer for integration with GitHub Codespaces

* Make sure the current development setup with Docker keeps working after the previous additions *

The configuration files for all three environments mentioned above should have as little duplicate code as possible so they're easy to maintain

* Update the technical documentation for both development and production environments

Duration of the Project

Medium Size 175 hrs

Related Repositories

https://github.com/consuldemocracy/consuldemocracy

Knowledge Prerequisites

* Experience deploying to production environments using Docker

* (Optional) Experience using Docker in Ruby on Rails applications

Mentors

Javier Martín - https://github.com/javierm, Sebastià Roig - https://github.com/taitus

Εxtending the apothesis factory pattern for seamless 2D and 3D lattice integration

Overview

Apothesis is a generalized software for designing, simulating, and analyzing deposition processes using the kinetic Monte Carlo method. It consists of two main components: a lattice (e.g., simple cubic, HPC, etc.) and the processes (adsorption, desorption, diffusion, and surface reactions) that occur within it. Currently, Apothesis includes a factory-based mechanism for lattice creation, but this implementation is limited in scope, primarily focusing on basic lattice structures. To enhance its flexibility and scalability, this proposal aims to extend the factory pattern to support a broader range of 2D and 3D surfaces in a seamless and modular way. This extension will involve introducing specialized lattice factories tailored for different geometries, such as hexagonal, face-centered cubic, and custom surface representations, ensuring compatibility with kinetic Monte Carlo processes. Additionally, a dynamic factory registry system will be implemented, allowing new lattice types to be registered and instantiated at runtime without modifying the core system. This approach will not only improve adaptability but also facilitate user-defined lattice structures while preserving maintainability and efficiency. By refining the factory mechanism, Apothesis will provide a more robust framework for deposition process simulations, enabling researchers and engineers to explore a wider range of surface dynamics with greater ease.

Related work

Apothesis already implements a factory pattern for lattice creation, but it needs to be expanded to support a broader range of 2D and 3D surfaces in a more seamless and flexible way. The current implementation primarily focuses on basic lattice structures, and extending it would involve introducing specialized factories for different geometries, such as hexagonal, face-centered cubic, and custom surface representations. Enhancing the factory pattern should include a more modular approach, allowing new lattice types to be dynamically registered and instantiated without modifying the core system. Additionally, ensuring that these new lattice structures fully integrate with kinetic Monte Carlo processes—such as adsorption, desorption, diffusion, and surface reactions—will be crucial for maintaining simulation accuracy and consistency. By refining the factory mechanism and introducing a more extensible registry system, Apothesis can achieve greater adaptability, making it easier for users to define and integrate new lattice types while preserving maintainability and scalability.

Details of your coding project

A potential practical approach to extending the factory pattern in Apothesis for 2D and 3D surfaces involves creating a modular and extensible lattice generation system. This can be achieved by defining an abstract LatticeFactory that enforces a standard way of creating lattice structures while delegating specific implementations to derived factories. Specialized factories such as SimpleCubicLatticeFactory, HexagonalLatticeFactory, FCCLatticeFactory, and GrapheneLatticeFactory can be implemented to handle different lattice geometries while ensuring compatibility with kinetic Monte Carlo processes like adsorption, desorption, diffusion, and surface reactions. Each factory produces a lattice object implementing a common ILattice interface, encapsulating geometry, boundary conditions, and process compatibility. A dynamic factory registry mechanism allows runtime selection and registration of new lattice types, enabling users to introduce custom lattices without modifying the core code. This approach ensures scalability, flexibility, and maintainability by decoupling lattice creation from simulation logic while seamlessly supporting both 2D and 3D structures.

Size

Large (350 hours)

Skills

Required: C++, desing patters, experience with physicochemical based software

Expected impact

The expected impact of extending the factory pattern in Apothesis includes enhanced flexibility, scalability, and efficiency in lattice creation for deposition process simulations. By introducing a more modular and extensible approach, researchers and engineers will be able to seamlessly integrate new 2D and 3D surface structures without modifying core code, reducing development time and increasing adaptability. The improved factory mechanism will ensure better compatibility with kinetic Monte Carlo processes, enabling more accurate and diverse simulations of adsorption, desorption, diffusion, and surface reactions. Additionally, the dynamic factory registry will foster customization and extensibility, allowing users to define and register their own lattice structures, thereby broadening the range of possible simulations. Overall, this enhancement will make Apothesis a more powerful and user-friendly tool, supporting advanced research, industrial applications, and innovation in surface science and material deposition technologies.

Mentors

• Nikolaos (Nikos) Cheimarios <n.cheimarios at gmail.com> is a researcher with contributions in scientific software development. He has previous experience as mentor in 2020, 2022, 2023 and 2024. He is one of the authors of Apothesis, Chameleon software and several web-based scientific numerical applications.

• Christianna Gatsiou <christianna.gatsiou at gmail.com>.

Tests

Students, the following test will be helpful. • Easy: Compile and run Apothesis for the CO heterogeneous catalysis case. • Medium: Perform runs with SimpleCubic and HPC lattices. • Hard: Identify the part of code that creates the lattices. Briefly describe how you would implement the 2D graphene lattice. For tips and references contact the Mentors!

References

[1] N. Cheimarios, D. To, G. Kokkoris, G. Memos and A.G. Boudouvis “Monte Carlo & Kinetic Monte Carlo models for deposition processes: A review of recent works”, Frontiers in Physics, 9, 165 (2021).

[2] N. Cheimarios, “Insights into the effect of growth on the Ziff-Gulari-Barshad model and the film properties”, Modelling and Simulation in Materials Science and Engineering, 31, 065007, (2023).

[3] A.P.F Jansen, "An Introduction to Kinetic Monte Carlo Simulations of Surface Reactions", Springer Berlin, Heidelberg, 2012. https://doi.org/10.1007/978-3-642-29488-4

[4] M. Andersen, C. Panosetti, K. Reuter, "A Practical Guide to Surface Kinetic Monte Carlo Simulations", Frontiers in Chemistry, 7, 202 (2019).

Identifying transition points in the ZGB model using convolutional neural networks (CNNs)

Scientific computing for physical/chemical sciences and engineering edited this page 3 weeks ago ·

Overview

In 1986, Ziff, Gulari, and Barshad introduced the ZGB model to computationally study the heterogeneous catalytic process of CO oxidation to CO₂ with O₂ on a metal surface (e.g., Pt). Using Monte Carlo simulations on a simple square lattice, with the partial pressure of CO, yCO, as the only parameter, they demonstrated that at low yCO values, the catalytic surface becomes poisoned (fully covered) by oxygen atoms, preventing the surface reaction and the conversion to CO₂. In this case, the system remains out of equilibrium. As yCO increases, at approximately y1 ≈ 0.389, the system transitions to an equilibrium state where CO begins to convert into CO₂. Further increasing yCO leads to a first-order, discontinuous phase transition at y2 ≈ 0.525, where CO conversion to CO₂ ceases again due to surface poisoning by CO atoms. In 1990, Jensen and Fogedby extended this model by incorporating diffusion phenomena, showing that the transition points shift depending on the diffusion rate, pd , but do not disappear.

Related work

Apothesis is a generalized open-source software for simulating heterogeneous catalysis and deposition processes via kMC. It is based on performing certain processes (adsorption, desorption, diffusion and surface reaction(s)) on lattices. Currently, Apothesis supports simple cubic, FCC, HPC and diamond lattices. It has been used to study both heterogeneous catalysis of CO and related type growth models [2].

Details of your coding project

This works aims to predict the transition points using machine learning methods, specifically convolutional neural networks (CNNs), based on surfaces derived from kinetic Monte Carlo simulations from Apothesis at equilibrium states. For that, an outer shell to Apothesis must be build that will read the data from Apothesis and use it for training a CNN and then for the prediction of the transition points.

Size

Large (350 hours)

Skills

Required: Python, Tensorflow, experience with physicochemical based software

Expected impact

The project will build an outer shell for Apothesis to be used in ML/AI applications.

Mentors

• Nikolaos (Nikos) Cheimarios <n.cheimarios at gmail.com> is a researcher with contributions in scientific software development. He has previous experience as mentor in GSoC 2020, 2022, 2023 and 2024. He is one of the authors of Apothesis, Chameleon software and several web-based scientific numerical applications.
• Konstantinos (Kostas) Eftaxias is a data scientist with more than 15 years of experience in research and industry applications. His main interests are computer vision, time series modelling/prediction and reinforcement learning.

Tests

Students, the following test will be helpful. • Easy: Compile and run Apothesis for the CO heterogeneous catalysis case. • Medium: Take three surfaces (SurfaceSpecies_*.dat) generated by Apothesis and read it in Python. • Hard: Call Apothesis from Python and read the latest surface generated. For tips and references contact the Mentors!

References

[1] R. M. Ziff, E. Gulari, and Y. Barshad, Kinetic Phase Transitions in an Irreversible Surface-Reaction Model, Phys. Rev. Lett. 56, 2553 (1986).

[2] I. Jensen and H. C. Fogedby, Kinetic Phase Transitions in a Surface-Reaction Model with Diffusion: Computer Simulations and Mean-Field Theory, Phys. Rev. A 42, 1969 (1990).

[3] N. Cheimarios, Surface diffusion effects on the system and the film properties of a Ziff–Gulari–Barshad type growth model, Mat. Today Comm. 39, 109189 (2024).

[4] N. Cheimarios, Mean field approximation of a surface-reaction growth model with dissociation, Phys. Lett. A 524, 129828 (2024).

[5] Y. Bahri, J. Kadmon, J. Pennington, S. S. Schoenholz, J. Sohl-Dickstein, S. Ganguli, Statistical Mechanics of Deep Learning, Annu. Rev. Condens.Matter Phys. 11, 501 (2020).

[6] D.W. Tola, M. Bekele, Machine Learning of Nonequilibrium Phase Transition in an Ising Model on Square Lattice, Condens. Matter 8, 83 (2023).

MyUni

Brief Explanation

There is a University App called MyUoM for Greek universities in https://my.uom.gr/ (followed by an effort in University of West Attica, https://iam.uniwa.gr/). While the app serves as a centralized platform for students and faculty, it currently lacks essential features such as a robust login system, a scalable backend architecture, and the ability to provide real-time updates from official university sources. Additionally, the app does not support a unified framework that allows other universities to easily integrate and customize the platform for their specific needs.

This project aims to address these limitations by developing a modern, scalable backend architecture and integrating a Content Management System (CMS) to manage frequently changing information. The CMS will enable universities to easily update and distribute news, announcements, and other critical data in real time. Furthermore, the backend will be designed to fetch and synchronize real-time information directly from official university websites, ensuring accuracy and timeliness.

A key goal of this project is to unify and standardize the efforts of existing implementations (e.g., MyUoM and UniWA) and create a modular, extensible framework that other universities can adopt with minimal effort. By doing so, we aim to foster collaboration among Greek universities and provide a seamless, feature-rich experience for students and faculty across the country.

This project will not only enhance the functionality of the existing app but also lay the foundation for a national university platform that can be easily extended to support additional institutions, features, and services in the future.

Expected Results.

1. Modular and Customizable Architecture: Develop a flexible, scalable structure that can be adapted to the unique needs of different universities. The system will allow each institution to fully customize the interface, content, and functionality to align with their specific requirements.
2. Personalized Content and Homepage: Implement a dynamic homepage that displays customizable tiles and content, similar to a WordPress-style page builder. Institutions can personalize the content to highlight important information, announcements, or services.
3. Student Portal: Create a dedicated student portal where all student-related data (personal information, academic records, etc.) will be centralized. This portal will serve as a one-stop reference point for students to access their information.
4. Admin Panel for Customization: Build an intuitive admin panel that allows university administrators to define the appearance, content, and functionality of their institution's application. This will empower institutions to manage their app independently.
5. Backend System for Data Management: Develop a robust backend system to handle all data, including student information, frequently updated content, and static resources (e.g., map images). The backend will ensure efficient data management and retrieval.
6. Real-Time Data Integration: Set up a backend that fetches real-time information from official university sources (e.g., announcements, schedules) and integrates static resources to reduce frontend load and improve performance.
7. TypeScript Rewrite for Maintainability: Rewrite the existing codebase in TypeScript to enhance code quality, maintainability, and scalability, ensuring the project is future-proof.
8. Custom CMS for Dynamic Content: Create a custom Content Management System (CMS) consisting of both FrontEnd and BackEnd components. This CMS will allow universities to easily manage and update frequently changing information.
9. Multi-Domain Support: Design a system where the application can be shared across multiple university domains by creating individual instances. This will enable seamless adoption by other institutions while maintaining customization for each.
   

Deliverables (before means to help us decide and after means at the end of GSoC)

1. Prepare the "Analysis and design" document. We want System Analysis, Feasibility Study, Business Procedures, User stories, EPICS, System Backlog, Requirements Analysis (before).
2. Wireframes or mockups (before).
3. Final Analysis and design document (after)
4. Repository with the code (after).
5. Docker image (after).

Duration of the Project

Depending on the scope

Related repositories

https://github.com/Open-Source-UoM/MyUoM

Knowledge Prerequisites

   • React.js
   • Express.js (for BackEnd)
   • MySQL (for BackEnd)
   • JavaScript
   • TypeScript
   • Next.js (optional)

Mentors:

Anastasios Tsalmas tsalmanastasios@gmail.com,

Efstathios Iosifidis eiosifidis@gmail.com

Contact:

There is a list. Please use the list. Write [myuni] as subject and cc both mentors. DON'T send us messages to social media (including Linkedin).

DIY IoT Physics Experiments for education

Brief Explanation

Remote physics experiments for students in all educational levels are the second best to hands-on experiments.  Especially for students who temporarily cannot attend school or in cases like Covid-19 and the lockdowns. In many practical cases, they are the only alternative, as they are available 24/7, they can involve dangerous materials or conditions, they can be accessed from anywhere and any device, they require less maintenance, have lower cost, can be easily modified, or arranged to perform another experiment, and are less probable to be damaged.  They are in line with the modern way of performing experiments, as it is desirable to have as little direct contact with the experiments as possible and use them online.  Examples include online telescopes and electronic microscopes.  This is possible due to automation; data acquisition and manipulation of the experimental data is done using a computer or a single board computer.  In this way students need not take pain stacking notes, especially for experiments that take a lot of time to collect data, sometimes days or months.  Students can concentrate on data processing, the analysis of the results, and arrive at scientifically valid conclusions.  Our laboratory has set up many remote experiments and has more than 10 years’ experience in designing, setting, and servicing remote experiments.  Our remote experiments are based on Arduino and readily available sensors and actuators. The previous year it was designed and implemented a way to make the sensors, and the actuators form an IoT local network so that it will be easier to easily utilize them in different experiments and to build new experiments.  The IoT sensors and actuators are DIY and based on open software.   The previous year GSoC stipend receiver, programed the ESP8266 to receive data from the sensor and transmit the data through MQTT to ThingsBoard. Similarly, for an actuator the ESP8266 to receive MQTT data from ThingsBoard. The stipend receiver prepared five DIY IoT sensors and five actuators. ThingsBoard provided users with visual representation of the data and the control of the experimental setup through dashboards.  There are produced five dashboards for five corresponding experiments.  The present successful applicant will have to produce a digital twin of the experiments.  This will involve open software for producing 3D models of five experiments, allowing them to manipulate the digital twins, view the evolution of the experiment, provide data presentation tools, and extract model parameters.

Exprected Outcome:

Five digital twins of corresponding five experiments, their documentation and instructions of how to use them

Knowledge Prerequisites

Any one for case a)-e) or similar --- a) 3D Web-Based Physics Simulations: Three.js, Babylon.js, p5.js, Godot b) Interactive Dashboards: Plotly Dash, Panel, Bokeh c) Custom Data Visualizations: D3.js, Matplotlib, Jupyter Notebooks d) Game-Based Physics Experiments: Godot, Babylon.js e) Embedded 3D Simulations: Three.js, Babylon.js

Mentors:

Hariton Polatoglou and Panagiotis Koustoumpardis

eCodeOrama, an educational interactive flow visualization tool for mit scratch programs

Brief Explanation

The project will create a interactive tool to extract, visualize graphically and edit (to improve the presentation of) the layout of the flow of code in blocks / scripts in a mit scratch program and their interaction with any messages or other external events. The tool will use rules to decide on many layout parameters (e.g. the position of the code blocks in the layout, the colors used, etc) but the user will be able to overwrite the default choices. The presentation will be compatible with the codeOrama code layout specification. The tool will also promote code understanding, especially to young students that use scratch, and will include debugging aids. The students can use this flow to better visualize and understand their program, to explain it to others, to debug it and to design extensions and modifications.

Expected Results

A tool to visualize and edit the layout of the event based script flow of a scratch program, keeping it compatible with the codeOrama code layout specification.

Duration of the Project

350 hours

Related repositories

https://github.com/sarantos40/eCodeOrama

Knowledge Prerequisites

python, mit scratch, gui development

Mentors:

Sarantos Kapidakis (sarantos.kapidakis@gmail.com), Chrysovalantis Sfyrakis