Nodarium is a WebApp with a node-based interface reminiscent of Blender or Houdini. Each node is an independent WebAssembly file, which makes the system extremely flexible. Currently, Nodarium is mainly used to create procedural 3D -Models of plants. What the project was missing so far was an online repository into which users can upload their own nodes.

As part of Dynaweek I developed an API that allows nodes to be saved, loaded and versioned. Users can upload their WASM files via the API, which runs them in an isolated environment. The structure, inputs and outputs of the nodes are recorded and stored Node gets versioning based on its SHA256 hash, which enables clear tracking of changes.

To implement it in just five days, I relied on technologies that enable fast work I Deno was chosen because it offers very good support for WebAssembly and Worker. For the web framework, I chose Hono because of its integration with OpenAPI and Zod. I implemented the database accesses with Drizzle ORM and chose Postgres as the database because it is robust and performant.

Looking back, it was a very good idea to define my requirements at the beginning. Because I was able to make technology decisions and prioritize features faster and more targeted.

Spotimizer is an application that makes sorting and organizing Spotify playlists a breeze. It is ready to use and offers seamless integration into the Spotify web interface.

Despite its simplicity and good documentation, the Spotify API has some limitations, such as the synchronization of the Spotify interface with the API data. This results in many requests for the smallest changes to the Spotify API. Technical problems with WSL and unexpected interruptions also made the work more difficult.

Spotimizer offers functions such as the dynamic adjustment of rankings by selecting random songs for playlist sorting.

Future goals are to improve the playback functionality and add more tools.

Kana is a card game in app form that combines elements of puzzle games, card battlers, and collectible card games (CCGs).

The game cards themselves are designed in the style of traditional Japanese woodblock art. Each card is linked to an audio file that provides the correct pronunciation in Japanese. This feature supports players both during battles and when browsing the card compendium, where all unlocked cards are stored.

The project explores the development of a dynamic racing game using Flutter and the Flame engine, integrating fundamental gameplay mechanics with interactive design and artificial intelligence concepts. The game allows users to design race tracks by clicking on the screen to define barriers that outline the track. Once a track is complete, a player-controlled car, represented as a circle, can navigate the course.

Collision detection between the car and track barriers introduces consequences for driving errors, as collisions disable the car's movement. The car is also equipped with sensors that measure distances to the nearest obstacles at various angles, allowing the use of a "ghost mode." In this mode, the car navigates the track on its own, attempting to maintain a central position based on sensor inputs.

A key goal of the project is to leverage machine learning and neural networks to evolve the car’s driving capabilities. By iteratively training AI models, the system aims to optimize the car's performance, achieving faster lap times with each generation. This approach draws inspiration from motorsports, focusing on how AI can refine racing lines and improve decision-making in high-speed scenarios.

The project serves multiple purposes. It is a hands-on exploration of new technologies and programming languages, in the context of game development. It also reflects a fascination with racing games and the complexity of AI-driven gameplay. Additionally, the project ties into a broader interest in motorsports, seeking to understand how AI models can influence racing strategies and competitive performance.

A formal language enables AI to describe card effects for a tactical card game. The task 'Create a Zeus card' results in expressions like '@Awake[Enemy]{AreaEffect}(1)[area:All]' - an appropriate thunder effect in machine-readable form.

A parser translates these expressions into playable mechanics. The AI pipeline not only generates effects but also matching illustrations, resulting in complete cards derived solely from thematic specifications.

The gameplay combines deckbuilding with tactical positioning. Generated cards integrate seamlessly into gameplay – from Zeus' devastating lightning to Proteus' transformative abilities.

The goal was to migrate the tower defense game "ChekUrDefence", developed during DynaWeek 2023, to the latest version of Godot and .NET, and to add a multiplayer feature.

Various options were evaluated for P2P communication between 2 players, and the decision was ultimately made to use "NAT Hole-Punching". This means that the host of the game does not need to have UPNP active, nor does a port need to be manually forwarded to the player's computer on their router.

NAT-traversal via hole punching is based on the fact that connections from a network behind a NAT router are assigned a mostly dynamic, temporary port for incoming communication.
In order to take advantage of this for direct P2P communication between two players, a signaling server – which is publicly accessible on the Internet and with which the game registers with a random "join code" after starting – was developed in C#. The signaling server stores the external IP and the return channel port for the provided code when a game registers itself.
The code is displayed to the player on the start screen and can thus be easily passed on. A second player can now also establish a connection to the signaling server via the "Join" menu, and by using the same code the signaling server knows the IPs and dynamic ports of both players and can communicate these to both running games. After that, both games can communicate directly with each other via IP and port.

Unfortunately, in the end there wasn't enough time to implement the actual multiplayer functionality within the game.

Our goal was to develop an Android notes app emphasizing usability. The app enables users to seamlessly combine text and checklists within the same note using an intuitive WYSIWYG editor. Notes are saved in Markdown format, facilitating easy synchronization and editing across multiple devices.

Many existing note-taking apps don't allow flexible integration of text and checklists in a single note, forcing users to choose between text-only notes and checklist-only notes. Our app specifically addresses this gap.

We chose Kotlin and Jetpack Compose to create a specialized, high-performance Android app. During development, we encountered challenges combining multiple widgets within a scrollable Activity. Additionally, we discovered limitations with the current implementation regarding smoothly moving the text cursor between different elements.