My Other Projects

Go For It! is a simple and stylish productivity app, featuring a to-do list, merged with a timer that keeps your focus on the current task. The application’s workflow is described in this YouTube video.

Storage and Synchronization

To-do lists are stored in the Todo.txt format. This simplifies synchronization with mobile devices and makes it possible to edit tasks using other front-ends, like my Todo.txt Kupfer Plugin.

If you already use Todo.txt, beware of the fact, that Go For It! automatically archives completed tasks to the done list!

Download and Installation

There is an official Launchpad PPA which can be used to acquire .deb packages for Ubuntu (derivates) >= 14.04. It is recommended to add the PPA for automatic updates:

sudo add-apt-repository ppa:go-for-it-team/go-for-it-daily && sudo apt-get update
sudo apt-get install go-for-it

The Windows version is available for download here.

It is possible to compile and run it on macOS, however a lot of work is required for better OS integration. Anyone who has experience with optimizing and bundling GTK apps for macOS (or would like to learn more about this topic), please feel free to have a look at the corresponding Github branch.

Development

Go For It! is free and open source software hosted on Github. All sorts of contributions are welcome!

I am currently hoping for people to maintain and improve the Windows branch, as well as create packages for other GNU/Linux distributions and OSX.

Icon Set Forge is an application for managing, maintaining, editing, or simply observing icon sets in a convenient manner. It is aimed to work on all major desktop operating systems, including GNU+Linux distributions, OS X, and Windows.

Motivation

I often find myself working on icon sets, especially when it comes to giving my own desktop a consistent look. I just cannot stand a single application icon stick out, not matching the overall appearance of my system, so I “just” create a link to an existing icon that fits semantically.

On Linux desktops, icons are arranged in a hierarchial directory structure, that classifies icons by resolution and context. This makes the aforementioned procedure less trivial than it sounds, because one has to copy icons of every resolution into the correct subdirectories. Similar problems sooner or later occur with every kind of icon set of considerable size.

Vision

My vision for Icon Set Forg e is the creation of a unified and versatile way of loading, exploring, editing and organizing icon sets. Using filters and grouping mechanisms, the user has the ability to execute operations on groups of icons in a smart, intuitive and automated way.

About

The project is being implemented in C++ using the Qt framework, which makes it possible to compile and run Icon Set Forge on all major desktop operating systems. I have released the source code under the GPLv3 and thereby declared it a free and open source project. Further information for both potential users and developers can be found on Github.

I gave my very best to provide a modular, extensible and well documented class design that makes it easy for others to write a parser that enables Icon Set Forge to work with their favourite icon set type (Android, iOS, Emoticons, …). Information for people interested in joining development can be found here.

Current State of Development

The main development focus has been on the underlying data structure so far. Nevertheless I provided a simple GUI implementation to demonstrate, that the code “under the hood” works and give an idea of what may be possible in the future. Right now the application is limited to parsing an index.theme file and displaying the corresponding icon set. Moreover simple operations like deletion can already be applied in memory, but are not written to disk yet.

Never forget to silence your phone before an important meeting or get woken up by email notifications at night again! Silentio can put your Android phone into silence or vibrate mode based on smart rules.

For example you might want to turn on vibrate mode as soon as you are participating in an event in your timetable calendar, to avoid interrupting your next lecture. Or maybe you want absolute silence during meetings, so you can add the keyword “meeting” and whenever this keyword is contained in an event title your phone is silenced.

The application is currently in open beta stage, which you can participate in by clicking here. Please tell me what you think. I appreciate all sorts of feedback and hope you enjoy the app :-)

Nasty Alarm is a network-programmable alarm clock that wont stop ringing until you get out of bed. I felt like it was about time to work on a little embedded project again and as I had this idea in mind for quite a while, I decided to build a prototype. This whole project does not aim to create a serious “product” (although I actually use it on a daily base), but was merely started for practicing some low level C programming.

Hardware

An Arduino is responsible for handling the alarm sound and stopping it upon movement detection. A simple infra-red movement detection module has been used for that purpose, which has to be positioned in the room accordingly. A Rasperry Pi acts as server that handles everything network-related as well as controlling the actual timer behaviour. When a timer is due, a particular GPIO port of the Raspberry is set to “high” which in turn fires an external interrupt of the Arduino. Using a more sophisticated bus, such as I2C, would of course be preferrable in a production system but for a quick prototype this unidirectional “communication strategy” works fairly well. Also the Arduino is not really necessary as the Raspberry Pi’s GPIO pins are sufficient for the given task. However, I wanted to practice low-level microcontroller programming in C, which is why I bought the Arduino in the first place.

Software

The Arduino IDE/library was not used. Instead I have written code targeted towards the Atmel microcontroller on the Arduino board. The code is compiled manually using avr-gcc and flashed via the command line using avrdude. Again, I have made this choice for the sake of learning and understanding “how to do it the hard way”. I do not see any rational reasons against using the more convenient Arduino tools (except maybe additional dependencies).

The server code on the Raspberry Pi has been written in C as well. That being said, the overall environment is fairly different, because it has a full operating system stack (Raspian) underneath. This means that typical POSIX functionality is available, such as system calls for sockets, file persistence and alarm signals. This makes it easier to implement something as complex as a “server” on a Raspberry than it would have been on the Arduino.

The “protocol” is not very sophisticated, as it currently only expects clients to send TCP packets with strings in “HH:MM” (24h) format for setting the alarm. The client is a simple command line application written in C++ using socket system calls for communication.

Potential Future Improvements

In the future it would be good to implement a simple API that allows clients not only to set but also to query the active alarm time in order to display it to the user. Also, the client has to know the server’s IP, which might be considered inconvenient. Using a network service discovery protocol like DNS-SD for that purpose would be an elegant extension.

Another addition would be a smartphone client, because most people do not want to start their computer, fire a up a terminal and type in a command to set the alarm (although it might sound appealing to us geeks :P). I would love to have a smartphone app that automatically synchronises Nasty Alarm with my phone’s alarm times (maybe with an offset of multiple minutes as to give the user a chance to get up before being “forced to do so”).

AiO was an app project aiming to create a multi messenger that displays all communication with one person in a unified chat history, with the goal of uniting the fragmented world of modern communication.

Motivation and Concept

The most versatile communication device of today is the smartphone. Several communication channels for such devices exist. But herein lies the boon and bane of modern communication.

Too many options cause confusion and in the worst case lead to fragmentation and separation, because not everyone wants to install hundreds of almost redundant apps.This is where AiO comes into play. Our goal is to provide a messaging solution that combines as many of those channels into one unified chat history as possible. The user shall focus on the question of whom to address, not how to.

The project was initiated and maintained by Marcus Held and me.

Technical Background

We designed AiO with modern software development patterns in mind and thus created a flexible and extensible system, with interfaces and strategies for groups of related communication styles. Due to this there is very few architectural overhead involved when implementing new protocols. Right now AiO supports sending and receiving SMS as an examplary implementation of that concept.

Current State of Development

Due to our recently rather demanding involvement in university studies, jobs and other projects, we are lacking the time to keep up active development of AiO. We underestimated the effort needed to integrate different protocols and third party APIs, which is a very valuable lesson for future projects. This does not mean the project is over, as we have a solid and extensible code base to build upon and may contribute to AiO again whenever we have more free capacities.

AR-Defense is an augmented reality tower defense game. Build towers to defend your table top - use the smartphone as a “window into the virtual world”.

The Idea

The game has been developed during a university project, that dealt with virtual environments and user interaction. Our group consisting of Tobias Hagemann, Marcus Held, Gennady Solomenikov and me wanted to create a tower defense game, using augmented reality techniques to interact with the game.

The Smartphone acts like a “window into the virtual world” that can be moved to navigate. The player can position towers by moving a special marker around and then finally place the tower via a tap on the screen. Furthermore the player can draw the path that enemies walk on by hand and then scan it in the beginning of a game. We followed this approach to create a truly immersive experience.

Technical Overview

The Vuforia framework is responsible for tracking the game markers. For rendering purposeses we used the free and open source scenegraph API Rajawali, which has been developed specifically for 3D graphics on Android. The recognition of hand drawn paths is implemented in terms of our own image processing algorithm.

The roles within the project cannot be clearly distinguished as we worked together a lot and solved the most demanding tasks as a team. Neverthless one can say that my main responsibility was the fusion of Vuforia’s input data and the underying game logic.

Demo

You can download a demo including the apk file, the markers to be printed and usage instructions. Keep in mind that this is to be considered a “proof of concept” instead of a fully polished game.

Escape is a surreal labyrinth game developed by Timo Kaul, Marcus Held and me during the course of the elective subject “Game Development” at our university.

The player’s goal consists of breaking out of the labyrinth by finding hidden levers within the level that open the exit. The game is set in a gloomy cavern supposed to create a constricting atmosphere underlined by scary sounds like clanking chains or frightening screams. The general message of this scenario is: “Sometimes one has to overcome his limitations, fears and sorrows to gain real freedom”.

Level Design

From a technical standpoint the most interesting part of Escape is it’s nonlinear level design. If the player leaves element A in forward direction he/she reaches element B. But after returning may find him/herself entering element C. While this creates the impression of surrealism, confusion and inconsistency, the game is 100% deterministic. If the player ends up in element B again and leaves backwards, he will always proceed to element C.

This level mechanism can be mathematically described as a graph. Every node represents a level element. Each level element has 4 edges (forward, backwards, left, right) which point to other level elements. Many scenarios are imaginable: An element connected to itself would result in an infinte hallway. Or one could design a curve that looks perfectly straight after turning around.

Technical Details and Implementation

Coming from different software development backgrounds we considered Java a good compromise everyone could get started with quickly. There was however a certain unease about using that language to develop a 3D game.

Nevertheless we decided to give the JMonkeyEngine a try, as it seemed to be a very convenient tool for building a true cross platform game within a short timespan. It turned out our assumption was correct.

The biggest hurdle was the implementation of our abstract level design into a three-dimensional game world. One cannot simply load the whole level into the game engine’s scene graph, because there are unnatural jumps and overlaps that prevent the level from being displayed thoroughly. So we developed an algorithm that determines, based on the players position and viewport, what part of the level is to be displayed at a time. This algorithm must be called whenever the player moves or changes the viewing angle.

Responsibilites within the Team

While Timo’s main task was the creation of textures and 3D models, Marcus and I focussed on the implementation of the game’s logic and graphics. We all participated in the recording of the sounds which I have mixed and cut afterwards.

Conclusion

Given the short period of time and limited manpower we are satisfied by the outcome of the project. There are two issues left unsolved. The first results in unshaded walls due to a problem with the way our textures got rendered by the engine. The second is a graver one, as it pertains the algorithm for rebuilding the scene graph. The algorithm itself works but it is not always triggered at the correct spots, which results in the level not being rebuilt properly. In the worst case, the player falls into void, because there is no floor underneath. When playing the demo, one can avoid that by going back and forth to trigger the rebuilding process, whenever the level is rendered faultily.

Future development is not currently planned as we are all occupied by other tasks and the whole project was limited to the duration of the lecture. But we consider releasing the whole game under a free licence to encourage others to join development. I will promote this on my blog, as soon as we decide to go that route.

Demo

A playable demo is available for download. As mentioned above it contains bugs, but should be fine enough for demonstrating our ideas and concepts.

Evolution XPert is an assistant app for the highly popular augmented reality game Pokémon GO which helps players optimize their evolution XP gain. The application deduces the right amount of Pokémon of a particular kind to transfer in order to maximize the amount of possible evolutions.

If this sounds like some nerdy gibberish to you but you would like to understand what all this is about, have a look at “Understanding the strategy”.

Understanding the strategy

The exciting new thing about Pokémon GO is that it actually makes you run around outside instead of sitting at your desk all day, but if you leave that fact aside it is still an RPG game. If you just “wanna catch em all” this should not be of much concern to you but there are many players out there who strive to reach higher and higher levels in order to catch higher and higher CP Pokémon which will enable them to conquer gyms or just show off (yeah, people actually do that).

The game rewards you with XP for many different actions such as collecting items from Pokéstops, catching wild Pokémon or fighting battles, but there is nothing as effective when it comes to leveling up as evoliving Pokémon - many of them. This is why many players have figured out that it makes sense to collect a lot of Pokémon (especially those with low candy requirements) and just try to perform as many evolutions as possible. This is even more important if you use one of those precious lucky eggs, which are items that double your XP gain for 30 minutes - its all about efficiency!

Evolutions cost candy, transferring Pokémon gives you candy but also makes you loose a potential evolution candidate. So Tobi and I figured out the maths to solve this simple optimization problem and wrapped it up in a pair of nice, little mobile apps so you can benefit from our insights.

I always wanted to build a robot. During my school career I once got the chance to write a physics term paper with the topic “Navigation of mobile robots via infra red emission”, which included a practical part, to underline the theory. I dedicated that practical part to the fulfillment of my “dream” of developing an autonomous robot.

IRENA is an acronym for “Infra Red Emission Navigated Automat”. It has the capability to navigate towards an IR light source while evading obstacles on its way.

Technical Implementation

The first task is accomplished via an IR photo diode amplified by a TLC272 connected to the microcontroller’s AD converter. For obstacle detection I created 4 modules which consist of an IR LED and an IS471F each. The IS471F is capable of both: generating a pulsed signal to be emitted by the LED and detecting it’s reflections. Due to its pulsed nature the IR bursts are less vulnerable to disturbances and allow the LED to be driven with a higher voltage which increases the sensor’s range.

IRENA’s “brain” is an Atmel ATMEGA32 which was affordable, yet powerful enough for the desired task. After being rather unsatisfied with BASCOM, a Basic dialect for microcontrollers, I researched on how to program Atmel controllers in C, which gave me all freedoms I needed and a good development workflow.

Besides electronics and code there is hardware needed for a robot to function. As I had no experience in that field I decided to use a simple assembly kit for the motor and designed an easily implementable setup, consisting of multiple layers of acrylic glass, that turned out to serve the purpose very well.

Kupfer is a command launcher, that is not only capable of starting applications but also supports file operations, web searches, media control and much more. The reason for its diversity is the number of available plugins. Kupfer is written in Python and has a flexible and well designed Plugin-API, which makes it easy to extend its functionality.

Plugins

I have written a few plugins for Kupfer so far, which can be found in my Github repository for Kupfer Plugins, of which File to Clipboard turned out to be the handiest. Whenever you want to open or save a file need to specify its path. With Kupfer, one can quickly navigate there (faster than I can with a file browser or even the terminal) and then, using my plugin, copy the file’s or directory’s path into the clipboard for pasting in the application of interest. Moreover it can copy a file’s content to the clipboard which I have not used that often to be honest.

Make new Directory does exactly what its name suggests: I creates subdirectories in the directory that is currently selected in Kupfer.

Parent Directory simply opens the directory a file is contained in via the system’s file browser.

Todo.txt is a plugin to add tasks to Gina Trapani’s super handy Todo.txt task manager. Note that Go For It! uses the same format to store todo lists, so they can be used in conjunction.

Death Bunny is a humorous and somewhat ironic Jump’n’Jump game (no running involved, we’re talking about a bunny on a pogo stick) with a special feature: There are periods of inverse death logic, i.e. the player has to jump into traps in order to survive. This makes the game highly confusing on higher difficulty levels.

It has been developed in the course of the Stacshack 2016 hackathon at the University of St Andrews, where it won the “funniest hack award”. While this might not be the most prestigeous category, it made a crazy, little bunny very happy (I am referring to the game’s protagonist, in case you were wondering…).

Matthias Kulow has allowed me to use his brilliant music which adds to the atmosphere of the game and underlines the changes of mood very well.

Play the Beta

Sorry, but downloads are currently no longer offered on this website.

The downloads previously available were just an early beta preview and apart from improved jumping physics and score-based difficulty growth almost exactly as delivered at the end of the hackathon. However, there are plans to polish, improve and ship the game on various platforms - so stay tuned!

Technology

Ever since Okam Studio released their Godot game engine to the public, I have been following the development of what I considered a highly promising project. During that period I have been hoping for a suitable occasion to use it in a project.

This is why I spontaneously decided to give it a go in the course of this year’s Stacshack. Godot is an easy-to-use and well-engineered professional tool that enabled me to build a game in the limited timespan of the hackathon without any preliminary knowledge.

The editor is easy to use and does not get in your way. The Python-esque scripting language is easy to learn and you will find yourself being highly productive after a short introductory period. The export functions allow you to easily target multiple platforms with a single code base. Moreover Godot is open source and written in C++, which makes it possible to easily extend the core functionality if needed.

All in all, I would highly recommend Godot to any indie developer planning to build a 2D or (not too demanding?) 3D game.

While this website serves mainly as portfolio of projects I have created myself or contributed major parts to, this post aims to keep track of various contributions I have made to different open source projects.

Budgie Desktop

I have added support for multiple batteries to the Budgie panel, which comes in handy for users of laptops like mine (Thinkpad t450s) who want to see the charging state of all batteries.

Budgie features the side panel Raven which contains an overview of all desktop notifications the user has missed. While this makes sense for private messages, calendar reminders and emails, most users do not want to be reminded that they “missed” a notification from a music player. I have created a pull request that makes it possible to edit a dconf key with applications to be ignored by Raven.

In addition to the above changes I have made a few contributions to the budgie next desktop, which has served as unstable development and experimentation sandbox and eventually lead to what we now know as budgie desktop. Most notable is the ability to collapse music player widgets in Raven.

Deepin Window Manager

The Deepin window manager is a fork of elementary’s window manager Gala with a somewhat different approach to multitasking and workspace management. I encountered and fixed a bug related to broken animations when switching workspaces in certain situations. The video below was created for the bug report and explpains the problem.

Lollypop Music Player

Lollypop is a modern music player for GTK desktops and as such makes use of so-called client side window decorations, i.e. the ability to place custom elements like toolbars in window title bars. Unfortunately not every window manager/desktop environment supports this, which is why the application determines the active desktop via system variables (similar to how I solved the same issue for Go For It!).

However this does not always lead to the desired behaviour. For example, older versions of XFCE did not support CSDs, while recent releases do. So I created a pull request which lets the user specify manually whether CSDs shall be enforced, regardless of the detected desktop environment.

Inkscape Android Icon Export Plugin

If you are an Android developer/designer working on a Linux box, chances are you create your vector graphics with Inkscape. I found a very handy plugin which handles icon exporting for different resolutions according to the standard Android drawable directory naming scheme.

However, when creating launcher icons, the files are to be placed in directories prefixed with mipmap instead of drawable, so I added an option for this behaviour.

Pantheon Files

I made it possible to navigate using forwards and backwards buttons with elementary OS’s file manager. While the changes are of minor nature, this was one of my first contributions to a project that popular and significant which has shown me that submitting changes to major open source projects is “nothing to be scared of”.

Variety

Variety is a wallpaper changer for Linux desktops with a lot of advanced features, such as automatic, keyword-based downloading. When I switched from Gala to Deepin window manager, I added support for this window manager to Variety.

gnome-settings-daemon-compat

While most desktop environments feature handling of media keys out of the box, people like me, who run a highly customized collection of modular components on a “DIY distro” like Arch often and up needing to perform media key handling using something like xbindkeys.

The AUR package gnome-settings-daemon-compat features a patched variant of an older version of the gnome-settings-daemon that allows to run the media key handler as a standalone service with nice on screen displays for volume and screen brightness levels.

I fixed a bug which caused the screen brightness level not to be displayed correctly. The hardest part was not fixing the bug as such, but properly formulating the pull request, because the PKGBUILD downloads the original tarball from a Gnome FTP server and applies patches to it. Thus I had to replicate these steps manually to get started with development. After finding the fix I had to formulate the diff to apply to the patch file and not the actual source code, which felt slightly cumbersome.

mLauncher

This application makes the creation of .desktop files, i.e. application launchers on Linux desktops, easy and convenient. I created a pull request for specifying the StartupWMClass parameter which is commonly used to match windows to their corresponding launcher files. Not setting this parameter properly can lead to issues like icon mismatch in docks or program launchers.

GetSimple CMS

I have created a few plugins, themes and tools for the GetSimple CMS.