Projects on Manuel's bits and bytes

Openflexure

Mon, 17 Aug 2026 18:11:54 +0000

This year I attended FOSDEM in Brussels, and I fell in love with the stand where the people from OpenFlexure were showing off their microscope.

A few months later, with some spare time and a 3D printer in need of a project, I gathered all the required bits and bolts from TLab and set aside a weekend for printing and assembly.

The version I built is the V7 Low Resolution, using a Raspberry Pi 3 and a NoIR camera. Once assembled, everything worked out of the box, and we could examine how leaves look at a magnification of 20×.

Don’t hesitate to build one yourself if you’ve always wanted to explore the world at a different scale. Leaves, water, insects — the list of everyday objects that can be observed with this microscope is endless. I uploaded a 3MF project to Printables with all parts distributed across 3 different beds, so they can easily be printed with different colours or materials.

And if 20× isn’t enough for you, you can always start with the High Resolution, or upgrade your low-resolution build with the required parts.

Matrix Server

Wed, 11 Mar 2026 08:28:28 +0000

Synapse Matrix Server Configuration

Recently I set up a Matrix homeserver on my personal infrastructure, using Caddy as a reverse proxy and Postgres as the database backend. There are other examples on the internet; these are just my two cents.

Synapse

The Matrix server I used is Synapse. The container requires three volumes:

/data stores runtime data, media uploads, and the signing key.
/var/lib/synapse provides a dedicated library path.
homeserver.yaml is bind-mounted read-only from the host.

To avoid permissions errors, I set the user’s UID to the same UID that will start the service. The ports are exposed instead of published since the host does not need to use them; they only need to be available to Caddy.

docker-compose.yaml

services:
 synapse:
 image: matrixdotorg/synapse:latest
 container_name: synapse
 restart: unless-stopped
 user: "1000:1000"
 expose:
 - "8008:8008"
 volumes:
 - ${VOLUME_PATH}/synapse/data:/data
 - ${VOLUME_PATH}/synapse/synapse:/var/lib/synapse
 - ./homeserver.yaml:/data/homeserver.yaml
 depends_on:
 - postgres

Synapse Configuration

Server identity: the server_name is the root domain, not the subdomain. This means user IDs appear as @user:example.org rather than @user:matrix.example.org. The serve_server_wellknown option tells Synapse to handle well-known requests internally as a fallback.

homeserver.yaml

server_name: "example.org"
serve_server_wellknown: true

The listener binds to all interfaces on port 8008 without TLS (tls: false). TLS termination happens at Caddy. The bind address needs to be 0.0.0.0 because the service will be listening on the Docker container port 8008.

homeserver.yaml

listeners:
 - bind_addresses:
 - "0.0.0.0"
 port: 8008
 resources:
 - compress: false
 names:
 - client
 - federation
 tls: false
 type: http
 x_forwarded: true

The environment variables defined here are not handled by Docker. Instead, a Python script managed by PyInfra will replace the variables with the right values before the files are pushed to the remote server.

homeserver.yaml

database:
 name: psycopg2
 args:
 user: ${SYNAPSE_USER}
 password: ${SYNAPSE_PASSWORD}
 database: ${SYNAPSE_DB}
 host: postgres
 port: 5432
 cp_min: 5
 cp_max: 10

The same principle applies to other secrets.

homeserver.yaml

enable_registration: false
registration_shared_secret: "${REGISTRATION_SHARED_SECRET}"
macaroon_secret_key: "${MACAROON_SECRET_KEY}"
form_secret: "${FORM_SECRET}"
signing_key_path: "/data/example.org.signing.key"

PostgreSQL Service

This was a bit trickier. I experienced some problems with collation and locales, so I pinned to a Debian-based image and wrote an init script that would set up the database for Synapse.

docker-compose.yaml

postgres:
 image: postgres:18-trixie
 container_name: synapse-postgres
 restart: unless-stopped
 volumes:
 - ${VOLUME_PATH}/postgres/data:/var/lib/postgresql
 - ./postgres-init.sh:/docker-entrypoint-initdb.d/init.sh:ro
 env_file:
 - .env
 environment:
 - SYNAPSE_DB
 - SYNAPSE_USER
 - SYNAPSE_PASSWORD
 - POSTGRES_PASSWORD
 healthcheck:
 test: ["CMD-SHELL", "pg_isready -U synapse"]
 interval: 10s
 timeout: 5s
 retries: 5

docker-entrypoint-initdb.d/init.sh

psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "postgres" <<-EOSQL
 CREATE USER "$SYNAPSE_USER" WITH PASSWORD '$SYNAPSE_PASSWORD';
 CREATE DATABASE "$SYNAPSE_DB" WITH OWNER="$SYNAPSE_USER" ENCODING='UTF8' LC_COLLATE='C' LC_CTYPE='C' TEMPLATE=template0;
EOSQL

Caddy Service

docker-compose.yaml

caddy:
 image: caddy:2-alpine
 container_name: synapse-caddy
 restart: unless-stopped
 ports:
 - "80:80"
 - "443:443"
 volumes:
 - ./Caddyfile:/etc/caddy/Caddyfile:ro
 - ${VOLUME_PATH}/caddy/data:/data
 - ${VOLUME_PATH}/caddy/config:/config
 env_file:
 - .env
 depends_on:
 - synapse
 command: caddy run --config /etc/caddy/Caddyfile --adapter caddyfile

Caddyfile Routing

The Caddy configuration handles two domains: the root domain for well-known delegation and the Matrix subdomain for actual traffic. The redirection is done to the Docker name instead of the host’s port.

Caddyfile

example.org {
 header /.well-known/matrix/* Content-Type application/json
 header /.well-known/matrix/* Access-Control-Allow-Origin *
 respond /.well-known/matrix/server `{"m.server": "matrix.example.org:443"}`
 respond /.well-known/matrix/client `{"m.homeserver":{"base_url":"https://matrix.example.org"},"m.identity_server":{"base_url":"https://identity.example.org"}}`
}

matrix.example.org {
 reverse_proxy /_matrix/* synapse:8008
 reverse_proxy /_synapse/client/* synapse:8008
}

DNS Requirements

The configuration requires DNS records that match the Caddyfile setup:

An A record for example.org pointing to the server IP
An A record for matrix.example.org pointing to the same IP

Final notes

To deploy the Matrix service I used two technologies that I’m getting familiar with:

Terraform, used to generate resources like a remote server on my cloud provider and the DNS entries.
PyInfra, an Ansible-like tool used to provision the server with the docker-compose.yaml, the configuration files, and the secrets substitution.

Hnefatafl

Sun, 10 Aug 2025 18:48:15 +0000

During my holidays, I’ve been reading Breve Historia de los Juegos de Mesa, a gentle introduction to the origin and history of various board games. From the earliest known examples, like the Royal Game of Ur, to modern mechanics.

The book describes an entire family of games originating in northern Europe, known as the Tafl family. These games share similar boards and rules, with variations depending on the region or time period. One such variation is Hnefatafl. The mechanics intrigued me, so I created a prototype using the most basic tools: pen and paper. After playing a few rounds with my son, I decided it deserved a wooden version.

After engraving the design onto spare wood and finishing it with varnish, I crafted my own board. It may not be the most beautiful, but it’s one I made with my own hands—and a little help from my youngest.

3d Printed Hooks

Sat, 31 May 2025 12:50:24 +0000

Recently I got a 3D printer and I have been experimenting with it. After a few prints for “very important things”, like a drill guide, a wine bottle holder or a Lego Extension Card for my Framework laptop, I thought that it was time to design something myself.

Since my pegboard had still enough room for tools but I run long time ago out of hooks, I took the original hooks and “copied” them in TinkerCAD. A couple of failed prints taught me the importance of measuring properly and count with the printing tolerances.

I’m very happy with the results, and now my pegboard is completely filled with tools. You can download the STL files at my Printables page

Dev Container Template

Thu, 23 Jan 2025 20:38:16 +0200

Dev Container is an open specification to build and use an OCI container as development environment. It is something I already used in my Chip 8 emulator for having a development environment that can be reused across platforms. Lately, I’ve been looking into Dev Container templates as a way to have reusable devcontainer.json files for new projects. The idea is that while a new project is setup, you can use a template as a starting point, and modify it from there for the new project needs. My template contains those features, VS Code extensions and settings that I always set when I start a new project. Making use of it for a new project is as simple as copying the .devcontainer folder of the template on your project or just use the devcontainer-cli:

devcontainer templates apply --template-id ghcr.io/mmartinortiz/devcontainer-templates/python

Chip8 Emulator

Sat, 21 Dec 2024 20:38:16 +0200

During the last months I’ve been developing a CHIP-8 emulator in Python. My main goal was to learn how an emulator works and how to program one. That’s why I tried to write as good and comprehensive code as possible. At this point, tagged as v1.0.0, I consider the emulator complete, as a piece of code that fully emulates a CHIP-8, which does not mean that I will not continue developing some new features now and then.

Here you can find the source code of my Chip-8 Emulator as well as links to the main resources I’ve used.

RGB Flowers

Tue, 28 May 2024 19:30:20 +0100

A beautiful and decorative pot with flowers created with my children. My contribution was some soldering and electronics for powering RGB LEDs that cycle across colors. The components used are a couple of RGB LEDs with their corresponding resistors and a Raspberry Pi Pico (my favorite microcontroller). The source code for the RGB cycle can be found on this repository. The project has been strongly inspired by a similar project from Adafruit.

The lighting flowers

Here are other small details of the project:

Greenhouse Sensor

Sun, 19 May 2024 11:35:16 +0200

This is a little project for our greenhouse. Even if we do not really need it (and I still need to make sure that the battery will be safe), this circuit uses a Raspberry Pi Pico for monitoring temperature, humidity, gas and and atmospheric pressure. The collected information is sent every 5 minutes to my Home Assistance instance via MQTT.

The Pico is powered by a rechargeable battery connected to a repurposed solar panel from the garden, but the charger module can also be connected to a phone charger. However, as the Pico goes to deep sleep when it is not running, the energy consumption is very low.

The shopping list, code and instructions can be found in my electronics repository.

Table Clock

Wed, 06 Mar 2024 20:36:30 +0100

Using an ESP32, a potentiometer, a temperature and humidity sensor, and a sleek 7-segment display, I crafted a functional and stylish addition to any workspace.

Nestled discreetly within the IKEA frame, this clock is not just about telling time. With a twist of the potentiometer, switch between displaying the time, current temperature, and humidity on the 7-segment display. The ESP32 acts as the silent orchestrator, ensuring seamless operation and connectivity, and using your Wifi to keep the time in sync with a NTP server.

Extensive instructions for building the clock within the frame can be found in my Make Project profile.

RGB Cabinet

Sun, 25 Feb 2024 15:37:08 +0100

What to do after creating a Space Invaders game for an RGB LED Matrix? Obviously, build a cabinet for RGB games. Using an online service called Boxes.py’s Console2 for designing the cabinet and the PiTop-4 to run the software, I iterated over the previous code and adapted it to the actuators provided by the PiTop: a potentiometer and a button.

Code and build instructions are available in the project’s GitHub repository.

Led Matrix Games

Sun, 11 Feb 2024 10:30:52 +0100

Embarking on the journey to build a video game from the ground up has always been one of my ambitions. Understanding the inner workings of a video game and implementing classics have been on my to-do list since my university days.

Utilizing a 64x64 LED matrix, a USB controller, and a Raspberry Pi, I programmed my first Pong and Space Invaders. Upon submitting my project to a contest on Make Projects, I was fortunate enough to win a fantastic pi-top. If you’re curious about the code, you can find it on my GitHub account, as always.

Pico Speed Wheel

Sat, 10 Feb 2024 13:19:47 +0100

In the late ’90s, I purchased a Genius DB15 Wheel controller for playing driving video games. Regrettably, it turned out to be a poor choice as the potentiometers used in constructing the wheel and gear produced significant noise. Moreover, the Windows driver available at that time couldn’t effectively handle the noise, resulting in a subpar driving game experience.

The controller ended up stored away in a box until 2020 when it resurfaced during a cleaning day. I opted to give it a fresh start by replacing the DB15 port with a Raspberry Pi Pico and writing my own software to eliminate the noise.

For a more detailed explanation and access to the code, check out my GitHub repository and Make Projects.

Master Robots Project

Sun, 07 Jan 2024 14:30:52 +0100

As part of my university studies, I undertook two projects centered around robots.

For my Computer Science degree, I worked on a project featuring a remote-controlled robot equipped with four infrared LEDs. Additionally, I developed a fully autonomous robot with the primary objective of locating and following the first robot. The progress and details of the project development are documented in its dedicated blog. You can also find videos, including one showcasing the end result, on my YouTube channel.

For my Master’s in Advanced Artificial Intelligence, I created a communication framework designed for robots operating in environments with unreliable communication. This framework enables autonomous agents to update their understanding of the tasks at hand as well as their knowledge of the surrounding environment.

Check out the video below for an implementation featuring virtual agents using the communication framework.

Throughout the project, I also designed a virtual laser specifically tailored for real robots.

Some scientific articles were authored during the development of the project:

The project was implemented using the ePuck robot, and I developed a software both in C++ and Python.