At one point recently, I was inspired to make an Ant Colony simulation game. The player would be responsible for planning the colony layout, drawing (pheromone) roads, and planning for disasters like predator attacks or floods. Once I got the path finding to a decent spot, I lost interest, and later realized that Dwarf Fortress has basically done the same thing, but better. Still, it was a good learning experience.

I’m going to post some binary packages here. They will likely be detected as a Virus by Windows Smart Screen or your antivirus software.

Installer exe | Standalone exe | Zip Package

Everything is © Dominic Schaedler.

L-Click: Dig Tunnel. This is intentionally slow
R-Click: Pathfind to click location. Will not be exact, as the game uses a grid for pathfinding
F1: Generate New Map
F2: Show debug screen. Contains FPS

The Porta-Pi


I’ve always loved the scene in Live Free or Die Hard where Matt Farrell is hacking using his old flip phone or in other movies when the heroes pull out their computers in these mini setups, with everything strapped into a nice convenient case. So I finally made one of my own.

This project requires knowledge of Linux Systems and Image Flashing.

A picture of the completed project; a Raspberry Pi 3 with a small touchscreen, strapped to a combination battery bank - solar phone charger.

A picture of the completed project; a Raspberry Pi 3 with a small touchscreen, strapped to a combination battery bank – solar phone charger.

Meet the Porta-Pi as I call it. The base computer is a Raspberry Pi 3, with a custom image to support the 3.5″ resistive touchscreen that plugs into the Pi’s GPIO pins. The case came with the screen. I re-flashed the custom image to a 32 GB Mico-SD card to give this thing quite a hefty storage capacity for a device of it’s size. Using Velcro, I mounted the whole enclosure on the back of a generic solar phone charger and battery bank, which provides power for a good amount of time. I was able to get the device set-up and listen to about 4 hours of music before it died. I haven’t done an idle drain test yet.

Between the touch keyboard that came pre-installed, and a wireless USB keyboard I have, navigating and performing basic system functions comes fairly naturally. The low resolution means that some menus are cluttered, but the only time I have issues is when they move off screen. For this, holding Left Alt on the keyboard lets me drag them around to reach all the settings.

I haven’t found daily use for it yet, as most of my computing gets done on my desktop. However, I’m sure someone can find a use for the thing.

An side angle view of the project.

An side angle view of the project.

A back view of the project.

A back view of the project.

A back view of the project.

A back view of the project.

In-Case Thermometer


The CSE 1010 class I took at UCONN required us to buy an Arduino kit for use during the course. While the course was extremely general, it did teach me the foundations of using an Arduino. Since we didn’t use all of the elements in the kit, I wanted to experiment with what was there. Thus, this project. Overall, the project shouldn’t take too long to assemble. More specifics about the screen and project can be found in the code below.

This project requires knowledge of Basic Electronics, Arduino Scripting, and may damage important hardware.

Arduino Source File

Google Home SMS Reader


My phone’s ringer is almost never on. Usually, it’s completely muted, not even on vibrate. I can’t check my phone at work, and I don’t like the swarm of constant notifications.

However, this causes a problem when I get back home and forget to turn the buzzer on. I’ve missed a lot texts because I simply didn’t hear them.

I received a Google Home for Christmas one year and I was hoping that it would help by reading my texts out to me. However, Google has yet to implement any function like this. So I’d have to build my own.



  • An Android Smartphone – Unfortunately, Apple hasn’t opened up iOS messages for other services.

  • IfTTT – If This Then That is a connecting service designed to hook together internet services that normally don’t work together. This is going to listen for messages on the phone.

  • A server or always on computer – I use a Raspberry Pi Model B as a server here, but anything that is running 24/7 will do

  • Python – Python is the programming language that runs our server software. Comes Pre-Installed on the Raspberry Pi. We need Python Version 3.5+

  • HomeAssistant – This is the real magic of the project. HA will listen for a web packet from IfTTT, and make a Text-To-Speech request to my Google Home. HA is also good for automating other Internet of Things devices, and acting as a dashboard for the Google Home. I use the instructions for installing on top of an existing Python Installation. Other methods may work, but I find this the easiest.

  • A Google Home – This project will work with any hardware that is compatible with HomeAssistant. I know that Google Assistant works, but it might also work for Alexa and other similar devices.


This project is a bit complex, and has a lot of moving parts. We need to break down the flow of what’s happening, and understand each piece.
First, I’m going to tackle the flow of information that happens.

  1. My Android phone receives a text message.

  2. IfTTT, which is listening for text messages, picks up the message and copies the content and sender name.

  3. IfTTT formats the message into a web request (json), including the sender’s name, message, and some other text that makes the end result sound more natural.

  4. IfTTT sends that web request to the Raspberry Pi.

  5. HomeAssistant, running on the Raspberry Pi, receives and decodes the web request.

  6. HomeAssistant takes the content of the web request, and formats a Text-To-Speech (TTS) request.

  7. HomeAssistant sends the TTS request to my Google Home.

  8. My Google Home sends the TTS request to the Google Assistant servers to process the text into audio.

  9. The Google Assistant servers send back audio to my Google Home, which the Google Home then plays.

Like I said, a lot of moving parts.
The way I like to think of this is like a train or bus system. There is no direct line connecting my text messages to the Google Home, so I have to make several connections and transfers to get to my destination. The end result is my Google Home playing a clean audio stream of SMS information that originated on my phone.

In some tech circles, this is called a Bodge. This isn’t a “clean” solution, but instead takes advantage of multiple interlinking parts that eventually get the job done. It’s bloated and messy, but has the end result we want. Tom Scott has an excellent YouTube Video talking about The Art of the Bodge.


Time to get building.
The easiest thing to get started with is IfTTT. You can find the app here.


Once installed, make an account or sign in, and click on the rightmost icon in the bottom toolbar. This opens a section called “My Applets.


Once here, hit the “Plus” icon at the top, and the New Applet screen opens. Click the blue “this” to select our applet’s trigger.


We want to find and select “Android SMS”


Select “Any new SMS received”


Now we have a trigger for our IfTTT applet. Now we select the action by pressing the blue “that” button.


We want to select the “Webhooks” action


And “Make a web request”


This is where the complexity starts to ramp up.


In the URL feild, we are going to put the following:

The areas with “xxx” are going to be filled in later. If you know your public IP address, you can fill that into . You can find your public IP address at The Method will be set to “Post” and the Content Type to “application/json”. In the body area, we are going to put:

{ "message":"Text From []. Message. []"}

When typing in the boxes, an option should appear called “Add Ingredient”. Where I have the sets of “[ ]” brackets, add the “ContactName” ingredient to the first one, and the “Text” ingredient to the second. The final result should look something like this:


Let’s take a minute to understand what’s happening here.

  • IfTTT is taking the Contact Name and the Text parts of the message, and sending those in the body of the web request. This body section is where we format what the Google Home will actually end up saying; this body portion is carried through the rest of the project.

  • The URL section is the destination of the Web Request. The “” will be filled in by the IP address of the receiving computer. The “api_password=xxxx” will prevent strangers from sending random requests to to HomeAssistant. More information about Internet Protocol (IP).

  • The Method is POST, which means we are sending information. Other options provide different interactions. More Information about Request Methods.

  • The Content Type is set to “application/json”. This will tell HomeAssistant what kind of message to expect and how it’s encoded. More Information about JSON.

The important thing to understand is, we are sending the Contact Name and Text to a location.

Hit the Check Mark at the top of the screen to complete the action.

The Applet Preview screen will come up, where you change the applet’s name, and decide if you want run notifications. Once you’re happy, hit “Finish”.

A Recommended Applet screen may come up, you can turn these on or use the arrow to leave. The IfTTT Applet is complete for now, and is ready to send messages from your phone.


Okay, now’s a good time to take a breather. IfTTT is a powerful tool that can connect most big name internet services together in complex and useful ways. What we just did is one of the more extreme interactions we can make, most just involve hitting some buttons to get the desired result.

While IfTTT runs their own servers to provide the service, HomeAssistant is an open source project, without a central company. Therefore, we have to run the server ourselves in order to make the connection. We might need to define a “server” here. A Server is a computer that runs a piece of software 24/7. It’s job is to make sure that the software is available any time that someone wants to access it. Websites are run on servers. which is why they are always accessible whenever you navigate to them (this wasn’t always the case, until major services like Google, Facebook and other big names made this the standard). The server we are setting up is also a website, but has some more features under the hood.

I used a Raspberry Pi Model B to host my server, but it can be done on any machine that can run Python 3.5+. Most tutorials for HA will assume that you are running a Linux computer, as opposed to a Windows or Mac. Linux is an open system, that allows complete control over the system, which is why it is popular for servers, advanced computers, and computer nerds.

The Raspberry Pi runs a custom version of Linux. I’ll try to keep this tutorial general to both Linux and Windows operating systems so that most people can follow along. Mac users, you don’t want to host a server on your computer. Apple is uncooperative when it comes to their operating systems.

If you are using a Pi, here’s a guide to getting one set up.

Most Linux computers come with Python installed. If yours doesn’t you probably know what you’re doing. In any case, running the following is always a safe bet:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python3

Linux is very complex, so if you’re new to it, I’d take some time to familiarize yourself with how the system works, how to navigate folders, how to run programs, and generally use the system. I’ll probably make a Linux Quick-Start guide at some point.

On Windows, we’ll be installing Python with an .exe file, like normal programs. Make sure to click the option that says “Add Python to PATH”, it will make our lives easier.


Finally to the good stuff.

We’ll be following this tutorial from the HomeAssistant Website to get running on Linux. Sorry Windows users.

There are a lot of options for installing HomeAssistant on Linux. The tutorial link I provided is the most straightforward, but still has some complexities that I’ve ignored. We’re going to get started by installing some necessary prerequisites. This tutorial is built for Ubuntu based systems, check your documentation for methods specific instructions for your system.

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python3 -y
sudo apt-get install screen -y

The tutorial wants us to use HomeAssistant under a Virtual Environment or it’s own user. Feel free to, but i prefer to use screen to start it and keep it out of my way. I’ll be skipping to step 4 and adapting for that.

mkdir homeassistant
cd homeassistant
python3 -m pip install wheel
python3 -m pip install homeassistant

The tutorial also provides auto-start instructions, or you can start it manually.


Once launched, HomeAssistant will take some time to do it’s own setup. It’s supposed to have a UI, but I’ve found it to be unreliable and prefer to use the web access instead. Once HomeAssistant is done with setup, we need to configure it. You should be able to access the web panel now.

Find your local IP address (Not Public) by typing ifconfig in a new terminal session. 

Linux will have IP Address under under the “wlan0” header:

inet 10.0.0.XXX

If yours isnt 10.0.0.XXX, it might be 192.168.X.XXX or some other set of front numbers, it depends on your router brand. Anything with “255” is incorrect, as well as anything with “1” at the end.

Once you’ve found your local IP address, you can connect to the web interface.

Using a computer on the same wifi or internet connection as the server, open up a web browser, and go to:

Where is your server’s local IP Address. If your browser is running on the same computer as your server, it will be



The last big thing to set up is the HomeAssistant config. This controls what HomeAssistant has access to, and other options.

The web interface may have already picked up your google home. You can experiment with the interface, using the media controls and sending TTS requests to the Google Home.

If HA hasnt found your Google Home yet, don’t worry. We’ll make sure that gets set up in the config.

The HomeAssistant configuration file controls which items appear on the web interface. We want to ensure that Google Services and TTS both work. We also need to modify some settings, so we’ll hit the important lines one at a time.

This is a copy of my configuration.yaml file, with personal information removed.

  # Name of the location where Home Assistant is running
  name: Home   
  # Location required to calculate the time the sun rises and sets 
  latitude: XX  
  longitude: XX 
  # Impacts weather/sunrise data (altitude above sea level in meters) 
  elevation: 0  
  # metric for Metric, imperial for Imperial  
  unit_system: imperial 
  # Pick yours from here: 
  time_zone: America/New_York 
  # Customization file 
  customize: !include customize.yaml
  # Show links to resources in log and frontend
  # Enables the frontend
  # Enables configuration UI
    # Secrets are defined in the file secrets.yaml
    api_password: XXXX
    # Uncomment this if you are using SSL/TLS, running in Docker container, etc.
    # base_url:
  # Checks for available updates Note: This component will send some information about your system to the developers to assist with development of Home Assistant. For more information, please see:
  # Optional, allows Home Assistant developers to focus on popular components.
  include_used_components: true
  # Discover some devices automatically
  # Allows you to issue voice commands from the frontend in enabled browsers
  # Enables support for tracking state changes over time
  # View all events in a logbook
  # Enables a map showing the location of tracked devices
  # Track the sun
  # Weather prediction
  sensor: platform: yr
  platform: uptime
  # Text to speech
  platform: google
  # Cloud
  group: !include groups.yaml
  automation: !include automations.yaml
  script: !include scripts.yaml

There are a lot of options available here that you may want to personalize. However, these are most important to us.

api_password: XXXX

This controls access to HomeAssistant Server. Set this to something you can remember, and change it in the IfTTT applet as well.


This line allows HomeAssistant to search for supported devices on the network.

tts:- platform: google

This line tells HomeAssistant exactly which TTS platform we are using.

If any of those lines are missing from the config, it’s important that you add them.

The configuration.yaml file should be in the homeassistant folder we created earlier. Modify it with ‘nano’ or your favorite editor.

nano configuration.yaml

Hopefully your configuration file is correct from the start, and you don’t have to modify it too much.


Okay, we’re almost done I swear. Make sure you’ve changed the api_password in both the config file and in the IfTTT applet.

The last step is to make the site open to the internet, so that IfTTT can send our message.

Port Forwarding opens a small hole in your internet connection, to allow specific traffic into your network. Each internet router has a different method, so you’ll need to find the instructions for yours. We want to open port 8123 for incoming and outgoing traffic on both UDP and TCP connections.

This website explains Port Forwarding really well, and has a lot of useful resources.


That’s It! We’re finally done.

Assuming everything got set up correctly, whenever you receive a text from someone, your Google Home will read it to you. Get someone to text you, or make an IfTTT Applet to text yourself.

That was a lot of work for such a simple request. All we wanted was for one device to send information to another device that it’s normally already connected to.

If there’s one thing this project displays is how complex the internet of things really is. Most systems these days are built on top of older parts, which are built on even older parts.

Hopefully you were able to pick something up while doing this project. Here’s some possible take home points:

  • Bodging is a perfectly fine way of making a project work

  • You can use IfTTT to connect internet services together

  • Servers are computers that remain on to provide a service

  • Python is a programming language that many services use

  • Python has sub-modules, that are installed using Pip

  • HomeAssistant connects Internet of Things devices on your home network

  • IP Addresses are like street addresses, and are how you communicate between computers.

  • There is a difference between your local and public IP Address

  • The Appdata folder in Windows contains saved program information

  • Port forwarding allows outside computers to access parts of your home network

Once this project is set up, as long as HomeAssistant stays running, it should work forever. IfTTT wont run while the phone is power saver mode, but otherwise runs in the background. It takes only a few seconds between receiving a text, and my google home reading it to me. This project has potential with other Google Home interactions, and uses in situations where someone is not able to read their texts, or wants other information from their phone.

This was a lot of work to get figured out, and to set up correctly. You will run into issues, and it will not work properly the first time, but that’s okay, it’s part of the building process. There’s a lot of room to branch off from this project; take a look at some of the links i provided.

Overall, I had a lot of fun doing this project. I love the satisfaction of a finishing a project and having it work just the way I want. I’m still running the programs almost 3 months later, and I appreciate having my texts read to me.



Tiles is a quirky little game I made in 2015 with a friend. It’s built in Gamemaker Studio, and was my first real attempt at completing a game for release. I brought my friend on to help with the level design, and now it’s almost impossible to complete. If you can’t beat it, don’t worry; neither can I.

Download a Copy of the Game here

The executable is unsigned so don’t be surprised if your antivirus picks it up.

You can also find a copy of the source code on the project’s Github Page.

This project should be treated as abandoned, although i may come back and refactor the code at some point in the future.