---
title: Posts tagged UGent
canonical: https://0110.be/tags/UGent
markdown_url: https://0110.be/tags/UGent.md
page: 0
posts_per_page: 30
total_posts: 139
filters:
tag: UGent
previous:
next: https://0110.be/tags/UGent.md?page=1
---
# Posts tagged UGent
## [Sampo-UI 4.0 released at SEMANTiCS 2026](https://0110.be/posts/Sampo-UI_4.0_released_at_SEMANTiCS_2026.md)
- Published: 2026-09-16T00:00:00Z
- Updated: 2026-09-16T13:08:21Z
- Author: Joren
- ID: 585
- Canonical: https://0110.be/posts/Sampo-UI_4.0_released_at_SEMANTiCS_2026
- Tags: [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
Sampo-UI 4 was officially released at the SEMANTiCS conference in Ghent. Together with Jahid Chetti, Heikki, Annastiina Ahola and Frederic Lamsens, we worked on bringing the GhentCDH fork back into the [main Sampo-UI repository](https://github.com/SemanticComputing/sampo-ui).
The release includes an updated software stack, a clearer separation between the shared core and project-specific configuration, and a new plug-in system. These changes make it easier to reuse components across projects and keep portals up to date.
The GhentCDH fork has now been merged upstream. Our work continues as part of the shared Sampo-UI project, in collaboration with the original SeCo team.
For more on the changes and their use in our projects, see [Sampo-UI Meets Ontop](https://0110.be/posts/Sampo-UI_Meets_Ontop%3A_Publishing_Relational_Digital_Humanities_Data_-_Semantics_2026).
```
---
## [Explore Intra-Belgian book translation flows with a SAMPO-UI](https://0110.be/posts/Explore_Intra-Belgian_book_translation_flows_with_a_SAMPO-UI.md)
- Published: 2026-09-16T00:00:00Z
- Updated: 2026-09-16T08:10:58Z
- Author: Joren
- ID: 584
- Canonical: https://0110.be/posts/Explore_Intra-Belgian_book_translation_flows_with_a_SAMPO-UI
- Tags: [Presentation](https://0110.be/tags/Presentation.md), [Projecten](https://0110.be/tags/Projecten.md), [Research papers](https://0110.be/tags/Research%20papers.md), [UGent](https://0110.be/tags/UGent.md)
Another contribution presented at the [SEMANTiCS conference](https://2026-eu.semantics.cc/) in Ghent was a Sampo-UI portal for the BELTRANS project. I made a small contribution to the software and the paper, working with colleagues at KBR, the Royal Library of Belgium.
> *[Explore Intra-Belgian book translation flows with a SAMPO-UI](https://0110.be/files/attachments/584/BELTRANS_SAMPO.pdf)*, Sven Lieber¹, Ann Van Camp¹, Joren Six², Julie M. Birkholz¹ ²
> ¹ KBR — Royal Library of Belgium
> ² Ghent University, Department of History & Ghent Centre for Digital Humanities
The BELTRANS project studied book translations between Dutch and French from 1970 to 2020, involving at least one Belgian author, scenarist, illustrator or editor. The resulting dataset brings together publication metadata from different libraries. Making these data available is one thing; making them easy to explore is another.
The [BELTRANS portal](https://w3id.org/kbr/beltrans/ui) uses Sampo-UI to let researchers filter publications, browse authors and publishers, explore maps and download selected data as CSV. It uses the modernized Sampo-UI core described in my [Sampo-UI Meets Ontop post](https://0110.be/posts/Sampo-UI_Meets_Ontop%3A_Publishing_Relational_Digital_Humanities_Data_-_Semantics_2026). Here, the data are served by QLever, a graph database with a SPARQL endpoint. The same interface components find another use, this time for translation history.
> **Abstract**: *In the field of Big Translation History, (historical) book translation flows are studied based on publication metadata. This research data is often kept internally or only provided as domain-specific MARC21 records, a standard library format. Within the recently completed BELTRANS project, we created a large integrated data corpus of worldwide translations between Dutch and French between 1970 and 2020, where at least one Belgian was involved as author, scenarist, illustrator or editor, to study intra-belgian book translation flows, and published the corpus as FAIR data. In this paper we present the SAMPO-UI-based platform that can be used by non-technical users to explore the underlying BELTRANS Linked Data corpus. The off-the-shelf software SAMPO-UI was configured to build a user interface allowing the exploration of our data related to book publications, authors, publishers and linked temporal and geospatial information. The different search perspectives, filters and visualizations enable researchers to explore the corpus or download self-chosen subsets, without having to process the large underlying data dumps. Both the application and corpus data are opened up in a sustainable way, i.e. besides deposits at research repositories, the application is hosted in the long term at the Royal Library of Belgium (KBR) and the integrated data is equipped with provenance information allowing to click-through to the related metadata records at different national libraries. Future work can extend the application itself with novel visualization techniques or different download formats if necessary. Also, this application can serve as a role model to inspire other researchers to distribute their corpora as Linked Data and via such a SAMPO-UI platform.*
The [BELTRANS corpus](https://doi.org/10.5281/zenodo.20668316) and the [portal configuration](https://github.com/kbrbe/beltrans-ui-config) are available for reuse.
---
## [Sampo-UI Meets Ontop: Publishing Relational Digital Humanities Data - Semantics 2026](https://0110.be/posts/Sampo-UI_Meets_Ontop%3A_Publishing_Relational_Digital_Humanities_Data_-_Semantics_2026.md)
- Published: 2026-09-16T00:00:00Z
- Updated: 2026-09-16T07:46:02Z
- Author: Joren
- ID: 582
- Canonical: https://0110.be/posts/Sampo-UI_Meets_Ontop%3A_Publishing_Relational_Digital_Humanities_Data_-_Semantics_2026
- Tags: [Code](https://0110.be/tags/Code.md), [GhentCDH](https://0110.be/tags/GhentCDH.md), [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
The [SEMANTiCS conference](https://2026-eu.semantics.cc/) took place in Ghent from 15 to 17 September 2026. Our contribution was a collaboration between GhentCDH and the Semantic Computing Research Group at Aalto University on publishing humanities data with Sampo-UI and Ontop.
> *[Sampo-UI Meets Ontop: Publishing Relational Digital Humanities Data on the Semantic Web](https://0110.be/files/attachments/582/semantics-poster-sampo-ui.pdf)*, Joren Six¹, Jahid Chetti¹, Annastiina Ahola², Frederic Lamsens¹, Heikki Rantala², Eero Hyvönen²
> ¹ Ghent University, Ghent Centre for Digital Humanities ([GhentCDH](https://www.ghentcdh.ugent.be))
> ² Aalto University, Department of Computer Science, Semantic Computing Research Group ([SeCo](https://seco.cs.aalto.fi))
At GhentCDH, we often publish research datasets in the digital humanities. Several projects need similar search filters, map visualizations and data exports. Sampo-UI makes it possible to reuse these components when the data is available as Linked Data. In collaboration with the original Sampo-UI team, we worked on modernizing the framework. Our first contribution separates the shared core from project-specific configuration, making updates and reuse more manageable. The second uses Ontop to expose existing *relational databases* through a SPARQL endpoint. This lets us use Sampo-UI while keeping the database infrastructure and tooling we already have. Having one fewer database system to maintain is welcome.
> **Abstract**: *The Sampo model and its Sampo-UI framework have become an established approach for publishing Cultural Heritage and Digital Humanities data on the Semantic Web. Sampo-UI enables exploration of data originating from SPARQL endpoints through faceted search across multiple views with seamlessly integrated visualization and data analytic tools. Here, we present two contributions to the Sampo-UI ecosystem: (i) a separation of Sampo-UI core from application-specific configuration; decoupling core and application simplifies updates and facilitates reuse of efforts, and (ii) the use of Ontop --- a virtual knowledge graph system --- to expose relational databases through a SPARQL endpoint and Sampo-UI. The use of relational databases and reuse of tooling and expertise around relational databases lower the operational burden of publishing small-to-medium-sized datasets typical of digital humanities projects. These contributions originated outside the original Sampo-UI team but were developed in collaboration with it, and are being prepared for upstream integration. We illustrate the approach with two projects at Ghent University: one on Roman coin finds in Belgium (NuMAD) and one on historic Belgian company data (BelHisFirm). Both portals run the same Sampo-UI core with a different configuration, and operate on existing institutional relational database infrastructure without a dedicated graph database.*
The demo below shows the NuMAD portal for exploring Roman coin finds in Belgium through the modernized Sampo-UI. Another [demo presents historical records of Belgian companies](https://0110.be/files/attachments/582/belhisfirm_demo.mp4) through the BelHisFirm portal. Both portals run the same Sampo-UI core with different configurations, demonstrating the flexibility of the system.
Alongside the [Sampo-UI Meets Ontop paper](https://0110.be/files/attachments/582/sampo-ui_ontop-semantics_2026.pdf), a [conference poster on Sampo-UI](https://0110.be/files/attachments/582/semantics-poster-sampo-ui.pdf) that I prepared is also available.
Video: NuMAD — exploring Roman coin finds in Belgium.
---
## [ Introduction to Sampo-UI at FedOSC Linked Open Data Visualisation Workshop](https://0110.be/posts/_Introduction_to_Sampo-UI_at_FedOSC_Linked_Open_Data_Visualisation_Workshop.md)
- Published: 2026-09-08T00:00:00Z
- Updated: 2026-09-08T12:02:58Z
- Author: Joren
- ID: 583
- Canonical: https://0110.be/posts/_Introduction_to_Sampo-UI_at_FedOSC_Linked_Open_Data_Visualisation_Workshop
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
FedOSC, the Belgian Federal Open Science Cloud, supports open science and research data management at Belgium's federal scientific institutions. On 8 September 2026, it organised a [day on data visualisation and Linked Open Data](https://fedosc.miraheze.org/wiki/Events/DataViz) at KIK-IRPA in Brussels, with talks, demos and a approaches on cultural heritage datasets.
My contribution to the closing talks was an introduction to Sampo-UI, an open-source framework for building search and visualisation interfaces on top of Linked Open Data. I explained why we use it at the Ghent Centre for Digital Humanities: several projects need similar filters, maps and data exports, so it makes sense to reuse a common framework. The presentation covers how Sampo-UI works, our contributions to it, and a practical example with the NuMAD coin database.
The [Sampo-UI presentation](https://0110.be/attachment/cors/2026.09.08-sampo-ui-fedosc-brussels/index.html) is available online and embedded below.
---
## [The age of AI exploits is here](https://0110.be/posts/The_age_of_AI_exploits_is_here.md)
- Published: 2026-05-18T00:00:00Z
- Updated: 2026-05-19T06:48:39Z
- Author: Joren
- ID: 580
- Canonical: https://0110.be/posts/The_age_of_AI_exploits_is_here
- Tags: [Code](https://0110.be/tags/Code.md), [UGent](https://0110.be/tags/UGent.md)
Fig: Gemini imagining the age of AI exploits.
The following text puts into words a change that I have seen happening the last month. At the Ghent Centre for Digital Humanities we manage a fleet of virtual servers on the Ghent University network and have first-hand experience with security incidents appearing regularly now. It has a different tone than other posts here: it was sent in as a letter for a newspaper but was not published. Let's see in a few years if the tone was too alarmist or if it holds up:
> *The newest generation of AI coding tools is a great asset for software developers. They help with understanding complex codebases, and assist in writing code. Used properly, AI coding tools increase software quality and developer productivity. Unfortunately, these powerful tools can also be used with bad intentions. AI coding tools are now sufficiently advanced to find and exploit bugs in software. They pose a threat to essentially all computing systems that form the underpinning of modern infrastructure: banking, aviation, industry, and education.*
>
> *While [earlier reports](https://www.theguardian.com/technology/2026/apr/22/what-is-anthropic-mythos-ai-threat-global-cybersecurity) still used conditional terms to describe these threats, now — only a couple of weeks later — the first effects are already here. With the help of AI coding tools, three bugs were found in Linux, an open-source operating system: [Copy.fail](https://copy.fail/), [Dirty Frag](https://github.com/V4bel/dirtyfrag), and [Fragnesia](https://ubuntu.com/blog/fragnesia-linux-vulnerability-fixes-available). These first AI-discovered exploits in a broadly deployed system form a watershed moment. The bugs led to service outages, but diligent IT teams quickly patched systems, limiting the impact. The effects of Mythos — widely considered the most capable system for finding bugs in software — are now also clear. Mozilla reported [finding and fixing around four hundred bugs](https://hacks.mozilla.org/2026/05/behind-the-scenes-hardening-firefox/) last month, where in a typical month around twenty similar bugs are discovered and patched. Not every bug is exploitable, but every exploit starts with a bug. The age of AI exploits is here.*
>
> *The transition to this new age will be painful. Many unmaintained systems are connected to the internet and will not receive security updates: IoT devices, orphaned servers, smartphones and proprietary systems locked in time. It will become easier to gain illegitimate access to these machines. The skills needed to break into such systems are diminishing. What previously required highly specialized experts or state actors is now within reach of a much broader pool of bad actors, due to the very tools that are meant to help developers.*
>
> *What can be done? Companies need more stringent cybersecurity policies today. The broader public needs awareness of this evolution and basic cybersecurity hygiene to keep devices up to date. And we need a regulatory framework that holds producers of computing systems responsible for updates over a longer lifespan. Unfortunately, we can not afford to collectively ignore this emerging reality*.
---
## [Interactive slides on sound, waves, grooves](https://0110.be/posts/Interactive_slides_on_sound%2C_waves%2C_grooves.md)
- Published: 2026-04-19T00:00:00Z
- Updated: 2026-04-20T21:58:03Z
- Author: Joren
- ID: 579
- Canonical: https://0110.be/posts/Interactive_slides_on_sound%2C_waves%2C_grooves
- Tags: [UGent](https://0110.be/tags/UGent.md)
Recently, my son's school teacher asked parents to come in and read in front of the class. I kindly declined, since I am not very comfortable doing voices in front of a room full of ten to twelve-year-olds. As an alternative, I proposed to explain some properties of sound and music, based on material I used [fifteen years ago for the kids' university](https://0110.be/posts/Kinderuniversiteit_-_Muziek_onder_de_microscoop%21): a series of workshops and lectures aimed at children. Unfortunately, after a couple of months, the teacher took me up on the offer.
Fifteen years ago, I painstakingly hand-coded - yes, this is becoming a thing - demos in the Java programming language to show properties of sound: an oscilloscope, a loudness level meter, a spectrogram, a pitch detector. This took ages but worked reasonably well to show basic properties of waves, sounds and music.
This time, I casually vibe-coded similar demos, not in Java but using self-contained, single-page web applications. Below one of the demos - on sound propagation - is included. With the aid of powerful AI coding tools, programming these interactive demos took only a couple of hours. Fifteen years ago, the hand-coded - arguably worse - versions of the demos took weeks. The main downside is that there is less pride or satisfaction in detailed prompting vs hand-coding.
Fig: visualization on sound propagation.
With frameworks like reveal.js it is straightforward to string together html pages in a single presentation. Here is the full presentation on [sound, waves and music in Dutch](https://0110.be/attachment/cors/2026.04.sounds-waves-grooves/index.html). Or check the [sound presentation github repository](https://github.com/JorenSix/geluiden_golven_grooves).
Giving the presentation went well and as far as I could tell, the kids were at least involved and may have learned a couple of things. Afterwards, I got some feedback via a parent that their kid was intrigued and got curious, so I will take that as a win.
Some takeaways:
* AI coding tools are great at creating stand-alone, interactive, shader-based visualizations and demos.
* Use web technologies for slides: great for multimedia, accessibility, distribution, and interactive slides.
* To create interactive slides where shaders or visual information is used the AI coding tool should be able to peer deep into the browser internals. This can be done with the Chrome DevTools MCP or a similar system. This feedback loop allows an LLM to improve on a single-shot attempt automatically.
---
## [Robot-mediated haptic feedback outperforms vision in violin duo coordination](https://0110.be/posts/Robot-mediated_haptic_feedback_outperforms_vision_in_violin_duo_coordination.md)
- Published: 2026-03-19T00:00:00Z
- Updated: 2026-03-24T19:34:20Z
- Author: Joren
- ID: 577
- Canonical: https://0110.be/posts/Robot-mediated_haptic_feedback_outperforms_vision_in_violin_duo_coordination
- Tags: [UGent](https://0110.be/tags/UGent.md)
A couple of former colleagues have just published the article [Robot-mediated haptic feedback outperforms vision in violin duo coordination ](https://www.science.org/doi/10.1126/scirobotics.aeb1901) in Science Robotics. The article is about providing guidance to violin players with an exoskeleton. Congratulations Alexandra, Mark and Canan!
It is the result of an European research project in which I was involved in only at the start. I did, however, also contribute to the study in a small but crucial way. During the experiment, the exoskeletons suddenly stopped working. I was asked to have a look and see if there was something to be done. I was a bit hesitant to go near these unique, expensive prototypes with a soldering iron but, after a couple of tense minutes and fixing some - easy to access - connections the arms came back alive. The experiment could continue and everybody started clapping and cheering. This is at least how I remember it. Perhaps that last part is not entirely accurate. Anyhow, I made it into the acknowledgments; thanks Ola.
> **Abstract** *Joint actions among humans rely on the integration of multiple sensory modalities, most notably auditory and visual cues, which support explicit communication between partners. However, haptic feedback provides a direct, implicit channel for sensorimotor communication, and its contribution to fine motor coordination in joint actions remains largely unexplored. Here, we demonstrate that haptic communication, rendered through bidirectionally coupled wearable robots, outperforms traditional auditory-visual feedback in a complex and challenging real-life joint action: ensemble violin performance.
First, we developed a pair of two–degree-of-freedom upper-limb exoskeletons capable of transparently following violinists’ natural movements and rendering viscoelastic torques proportional to the joint angular deviation between the partners. Then, we designed a within-subject experiment with 20 violin duos performing a musical piece under four sensory feedback conditions: auditory (A), auditory-visual (AV), auditory-haptic (AH), and auditory-visual-haptic (AVH), across two tempi (72 and 100 beats per minute). Despite the musicians being unfamiliar with the robot-mediated haptic feedback and unaware of the bidirectional connection between them, haptic feedback (AH and AVH) substantially enhanced spatiotemporal coordination and dynamic musical alignment compared with the extensively trained auditory-visual feedback (A and AV). The multisensory feedback condition AVH yielded the highest scores across all measures. Our findings demonstrate that haptic feedback can support fine motor coordination in violin duo performance more effectively than visual cues, particularly for professional musicians, because of its implicit and embodied nature, and that it can be effectively delivered via wearable robots, expanding the paradigms of human-human sensorimotor interactions.*
---
## [Guest lecture on \`Music Information Retrieval - Opportunities for digital musicology'](https://0110.be/posts/Guest_lecture_on_%60Music_Information_Retrieval_-_Opportunities_for_digital_musicology%27.md)
- Published: 2025-11-13T00:00:00Z
- Updated: 2025-11-13T11:19:36Z
- Author: Joren
- ID: 572
- Canonical: https://0110.be/posts/Guest_lecture_on_%60Music_Information_Retrieval_-_Opportunities_for_digital_musicology%27
- Tags: [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
This morning I gave a guest lecture introducing the field of music information retrieval to musicology students at Ghent University. Next to the more general MIR intro, two specific topics are fleshed out: duplicate detection and pitch patterns in music around the world. Two topic I have been working on before.
The presentation has the form of an interactive website via [reveal.js](https://revealjs.com/). It features a couple of slides which are full-blown applications or have an interactive sound visualization component. Please do try out the slides and check the [Music Information Retrieval - Opportunities for digital musicology](https://0110.be/attachment/cors/2025.11.MIR-Intro/index.html) presentation or try it below.
- [MIR\_intro.pdf](https://0110.be/files/attachments/572/MIR_intro.pdf)
---
## [USB MIDI support on ESP32: the ESP32-S3](https://0110.be/posts/USB_MIDI_support_on_ESP32%3A_the_ESP32-S3.md)
- Published: 2025-11-13T00:00:00Z
- Updated: 2025-11-13T20:57:46Z
- Author: Joren
- ID: 563
- Canonical: https://0110.be/posts/USB_MIDI_support_on_ESP32%3A_the_ESP32-S3
- Tags: [UGent](https://0110.be/tags/UGent.md)
If you’re considering adding USB MIDI functionality to a music project with an ESP32, it’s crucial to choose the right variant of the chip. The ESP32-S3 is currently the go-to model for USB-related tasks thanks to its native USB capabilities. Unlike other ESP32 models, the S3 can handle USB MIDI directly without the need for additional components, making it an ideal choice for integrating MIDI devices into your setup. For more details on using USB MIDI with the ESP32-S3, check out the [ESP32USBMIDI project](https://github.com/esp32beans/ESP32USBMIDI).
When combined with the ESP32-S3’s built-in WiFi and support for OSC (Open Sound Control) or ESP Now, the platform becomes very versatile for music controllers or applications. A quick tip: after flashing your device in MIDI mode, the serial is not available any more. Flashing the device also becomes impossible. If you need to reflash your device, the process is simple: just hold down the Boot button and press Reset.
Another short tip: for troubleshooting and logging, the [mot project](https://github.com/JorenSix/mot) provides useful tools for debugging OSC or MIDI messages. The support is currently [stil in flux](https://github.com/espressif/arduino-esp32/issues/10978) but do not make the mistake I made and do not try to do MIDI with a ESP C3 series.
---
## [Pompernikkel - the Interactive speaking pumpkin 🎃](https://0110.be/posts/Pompernikkel_-_the_Interactive_speaking_pumpkin_%F0%9F%8E%83.md)
- Published: 2025-11-03T00:00:00Z
- Updated: 2025-11-14T09:34:42Z
- Author: Joren
- ID: 570
- Canonical: https://0110.be/posts/Pompernikkel_-_the_Interactive_speaking_pumpkin_%F0%9F%8E%83
- Tags: [0110.be](https://0110.be/tags/0110.be.md), [Projecten](https://0110.be/tags/Projecten.md), [UGent](https://0110.be/tags/UGent.md)
The last few halloweens I have been building one-off interactive installations for visiting trick-or-treaters. I did not document the build of last year, but the year before I built an [interactive door bell with a jump scare door projection](https://0110.be/posts/Doorbell_triggered_Halloween_window_projection). This year I was trying to take it easy but my son came up with the idea of doing something with a talking pumpkin. I mumbled something about feasibility so he promptly invited all his friends to come over on Halloween to talk to a pumpkin. So I got to work and tried to build something. This blog post documents this build.
A talking pumkin needs a few functions. It needs to understand kids talking in Dutch, it needs to be able to respond with a somewhat logical respons and ideally have a memory about previous interactions. It also needs a way to do turn-taking: indicating who is speaking and listening. It also needs a face and a name. For the name we quickly settled on Pompernikkel.
For the face I tried a few interactive visualisations: a 3D implementation with three.js and a shader based approach but eventually setteled on an approach of using an SVG and CSS animations to make the face come alive. This approach makes it doable to control animations with javascript since animating a part of the pumkin means adding or removing a css class. See below for the result
The other functions I used the following components.
* A decent quality bluetooth speaker for audio output and clear voice projection
* A microphone setup to capture and record children's voices speaking to the pumpkin
* A glass door serving as a projection surface with a projector mounted behind it
* Speech-to-text recognition powered by nvidia/parakeet-tdt-0.6b-v3 (see [this paper](https://arxiv.org/pdf/2509.14128)), implemented via [transcribe-rs](https://github.com/cjpais/transcribe-rs) for transcribing Dutch speech
* Text-to-speech synthesis using the built-in macOS 'say' command to give Pompernikkel a voice
* A controllable interactive projection system displaying the animated SVG website mentioned above
* Response generation handled by the Gemma 3 12B large language model ([paper](https://arxiv.org/pdf/2503.19786)), running locally through [Ollama](https://ollama.com/) with a custom system prompt
* A real pumpkin augmented with an ESP32 microcontroller and capacitive touch sensor embedded inside to detect physical touch - the microphone would only activate while someone was touching the pumpkin
* A custom Ruby websocket driver orchestrating turn-taking behavior and managing the interactive loop of questions and responses
As an extra feature, I implemented a jump scare where a sudden movement would trigger lightning and thunder:
* [EMI-Kit](https://github.com/IPEM/EMI-kit) for responsive movement detection. The mDNS support really makes it easy to use together with [mot](https://github.com/JorenSix/mot).
* A 5V SK6812 LED strip controlled by an ESP32 programmed to react to EMI-Kit events, creating lightning effects synchronized with audio and visual elements on the HTML page
### Lessons learned
* Asking a code assisting LLM to add animations to a part of an SVG only works after manually adding identifiers to paths of the svg: eyes, mouth, nose, ... Once added, CSS animation are generated with ease. Understanding which svg path corresponds to which semantic object seems out of reach for now for state of the art systems.
* Gemma 3 is not a multilingual LLM. It generates responses in Dutch but these seem very *translated*: it seems that responses are generated in Eglish and translated to Dutch in the final step. This becomes very clear when the LLM attempts jokes. Of course these nonsensical jokes do work on a certain level.
* Gemma 3 has a personality that is difficult to get around if a system promt contains trigger words like dark or scary. In my case it responses became philosophical, nihilistic and very dark. Which was unexpectedly great.
* Parakeet speech to text in Dutch is faster than the several OpenAI Whisper based systems I managed to get running on my macOS. It also gave better results for short excerpts.
* The SK6812 RGBWW is not the best supported by the FastLED library. I managed to get it working with a hack found on GitHub, not ideal.
* There are a few end-to-end systems for voice chat with local LLMs on GitHub but they are not easy to get going with something else than CUDA/linux and almost never support other languages than English. For VAD and transcription the same holds.
* Looking closely to several speech to text or text to speech sysems, the default of CUDA/Linux is difficult to get around.
* The focus of open source models and tools on the English language is problematic, while Dutch is still relatively well represented many systems are limited to only English.
* While some kids interacted with the pumpkin, the jump scare lighting and thunder effect worked better in the environment.
* Websockets seems a decent way to do inter process communication, even without web technologies it could be considered. I never though of Websockets in this way. See the [Pompernikkel GitHub repository](https://github.com/JorenSix/Pompernikkel) for example Ruby scripts.
Most trick-or-treaters were at least intrigued by it, my son's friends were impressed, and I got to learn a couple of things, see above. Next year, however, I will try to take it easy.
---
## [FFmpeg with Whisper support on macOS via Homebrew](https://0110.be/posts/FFmpeg_with_Whisper_support_on_macOS_via_Homebrew.md)
- Published: 2025-10-22T00:00:00Z
- Updated: 2025-11-03T13:40:09Z
- Author: Joren
- ID: 568
- Canonical: https://0110.be/posts/FFmpeg_with_Whisper_support_on_macOS_via_Homebrew
- Tags: [Code](https://0110.be/tags/Code.md), [UGent](https://0110.be/tags/UGent.md)
Since a couple of months FFmpeg supports audio transcription via OpenAI Whisper and Wisper-cpp. This allows to automatically transcribe interviews and podcasts or generate subtitles for videos. Most packaged versions of the command line tool `ffmpeg` do not ship with this option enabled. Here we show how to do this on macOS with the Homebrew package manager. On other platforms similar configuration will apply.
On macOS there is a prepared Homebrew keg which allows to enable or disable the many `ffmpeg` options. If you already have `ffmpeg` without options installed you may need to uninstall the current version and install a version with chosen options. See below on how to do this:
```bash
# check if you already have ffmpeg with whisper enabled
ffmpeg --help filter=whisper
# uninstall current ffmpeg, it will be replaced with a version with whisper
brew uninstall ffmpeg
# add a brew tap which provides options to install ffmpeg from source
brew tap homebrew-ffmpeg/ffmpeg
# this commands adds most common functionality and other default functions
brew install homebrew-ffmpeg/ffmpeg/ffmpeg \
--with-fdk-aac \
--with-jpeg-xl \
--with-libgsm \
--with-libplacebo \
--with-librist \
--with-librsvg \
--with-libsoxr \
--with-libssh \
--with-libvidstab \
--with-libxml2 \
--with-openal-soft \
--with-openapv \
--with-openh264 \
--with-openjpeg \
--with-openssl \
--with-rav1e \
--with-rtmpdump \
--with-rubberband \
--with-speex \
--with-srt \
--with-webp \
--with-whisper-cpp
```
Installation will take a while since many dependencies are required for the many options. Once the build is finished the `whisper` filter should be available in FFmpeg. See below on how this should look, once correctly installed:
```
ffmpeg version 8.0 Copyright (c) 2000-2025 the FFmpeg developers
built with Apple clang version
...
Filter whisper
Transcribe audio using whisper.cpp.
Inputs:
#0: default (audio)
Outputs:
#0: default (audio)
whisper AVOptions:
model ..F.A...... Path to the whisper.cpp model file
language ..F.A...... Language for transcription ('auto' for auto-detect) (default "auto")
queue ..F.A...... Audio queue size (default 3)
use_gpu ..F.A...... Use GPU for processing (default true)
gpu_device ..F.A...... GPU device to use (from 0 to INT_MAX) (default 0)
destination ..F.A...... Output destination (default "")
format ..F.A...... Output format (text|srt|json) (default "text")
vad_model ..F.A...... Path to the VAD model file
vad_threshold ..F.A...... VAD threshold (from 0 to 1) (default 0.5)
vad_min_speech_duration ..F.A...... Minimum speech duration for VAD (default 0.1)
vad_min_silence_duration ..F.A...... Minimum silence duration for VAD (default 0.5)
```
---
## [MuTechLab - Music Technology Workshop in Luxembourg](https://0110.be/posts/MuTechLab_-_Music_Technology_Workshop_in_Luxembourg.md)
- Published: 2025-10-02T00:00:00Z
- Updated: 2025-10-06T13:21:03Z
- Author: Joren
- ID: 567
- Canonical: https://0110.be/posts/MuTechLab_-_Music_Technology_Workshop_in_Luxembourg
- Tags: [Code](https://0110.be/tags/Code.md), [Projecten](https://0110.be/tags/Projecten.md), [UGent](https://0110.be/tags/UGent.md)
Last Friday, I had the pleasure of facilitating a hands-on workshop in Luxembourg as part of [MuTechLab workshop series](https://www.uni.lu/fhse-en/research-projects/mutechlab/), organized by [Luc Nijs](https://www.uni.lu/fhse-en/people/luc-nijs/) at the University of Luxembourg. Together with Bart Moens from [XRHIL](https://xrhil.ugent.be) and [IPEM](https://www.ugent.be/lw/kunstwetenschappen/ipem/en), we presented a system to control musical parameters with body movement.
MuTechLab is a series of workshops for music teachers who wish to dive into the world of music technology. Funded by the Luxembourgish National Research Fund (FNR, PSP-Classic), the initiative brings together educators eager to explore how technology can enhance music education and creative practice.
### What we built and presented
During the workshop, participants got hands-on experience with the [EMI-Kit](https://github.com/IPEM/EMI-kit) (Embodied Music Interface Kit) – an open-source, low-cost system that allows musicians to control Digital Audio Workstation (DAW) parameters through body movement.
The EMI-Kit consists of:
- **A wearable sensor device** (M5StickC Plus2) that captures body orientation and gestures
- **A receiver unit** (M5Stack STAMP S3A) that converts sensor data to MIDI messages
Unlike expensive commercial alternatives, EMI-Kit is fully open source, customizable, and designed specifically for creative music practice and embodied music interaction practice and research.
### The Experience
Teachers experimented with mapping natural body movements – pitch, yaw, roll, and tap gestures – to various musical parameters in their DAWs. The low-latency wireless system made it possible to move and control sound, opening up new possibilities for expressive musical performance and pedagogy.
### Learn More
Interested in exploring embodied music interaction yourself? Check out:
- [MuTechLab Project Page](https://www.uni.lu/fhse-en/research-projects/mutechlab/)
- [EMI-Kit on GitHub](https://github.com/IPEM/EMI-kit)
The EMI-Kit project as-is is a demonstrator to inspire educators to embrace these tools and imagine new ways of teaching and creating music. The EMI-Kit as a platform can - with some additional programming - be a good basis to control musical parameters using various sensors. Have fun with checking out the EMI-Kit.
---
## [MIDI and OSC tools improvements - MIDI processing and mDNS support](https://0110.be/posts/MIDI_and_OSC_tools_improvements__-_MIDI_processing_and_mDNS_support.md)
- Published: 2025-10-02T00:00:00Z
- Updated: 2025-10-06T13:54:28Z
- Author: Joren
- ID: 566
- Canonical: https://0110.be/posts/MIDI_and_OSC_tools_improvements__-_MIDI_processing_and_mDNS_support
- Tags: [Code](https://0110.be/tags/Code.md), [Music Information Retrieval](https://0110.be/tags/Music%20Information%20Retrieval.md), [UGent](https://0110.be/tags/UGent.md)
I've just pushed some updates to [mot](https://github.com/JorenSix/mot) — a command-line application for working with OSC and MIDI messages. My LLM tells me that these are exciting updates but I am not entirely sure that this is the case. Let me know if this ticks your box and seek professional help.
### 1. Scriptable MIDI Processor via Lua
I have implemented a **MIDI processor** that lets you transform, filter, and generate MIDI messages using [Lua](https://www.lua.org/about.html) scripts.
**Why is this useful?** MIDI processors act as middlemen between your input devices and output destinations.You can do the following on incoming MIDI messages:
- **Transform** - Transpose notes, generate chords, map velocity curves
- **Filter** - Block unwanted messages - channels - or select specific ranges
- **Route** - Send different notes to different channel
- **Generate** - Create complex patterns from simple input
The processor reads incoming MIDI from a physical device, processes it through your Lua script, and outputs the modified messages to a virtual MIDI port that your DAW or synth can receive. Some examples:
```ruby
# Generate chords from single notes
mot midi_processor --script scripts/chord_generator.lua 0 6666
# Transpose notes up by one octave
mot midi_processor --script scripts/example_processor.lua 0 6666
```
### 2. Network Discovery via mDNS
OSC receivers now **advertise themselves on the network** using mDNS/Bonjour with the `_osc._udp` service type.
This makes mot compatible with the [EMI-kit](https://github.com/IPEM/EMI-kit) — the Embodied Music Interface Kit developed at IPEM, Ghent University. OSC-enabled devices can automatically discover mot receivers on your network, eliminating manual configuration if the OSC sources add this functionality.
### Get started
Installation via Rust's cargo:
```ruby
git clone https://github.com/JorenSix/mot.git
cd mot
cargo install --path .
mot midi_processor -h
```
Check out the [mot repository](https://github.com/JorenSix/mot) for full documentation and example Lua scripts!
---
## [Newline.gent - A yearly hacker conference](https://0110.be/posts/Newline.gent_-_A_yearly_hacker_conference.md)
- Published: 2025-05-24T00:00:00Z
- Updated: 2025-06-03T13:53:12Z
- Author: Joren
- ID: 565
- Canonical: https://0110.be/posts/Newline.gent_-_A_yearly_hacker_conference
- Tags: [Hackerspace Ghent](https://0110.be/tags/Hackerspace%20Ghent.md), [UGent](https://0110.be/tags/UGent.md)
This weekend the - more-or-less - yearly conference of [Hackerspace Ghent](https://hackerspace.gent/) took place: [Newline.gent](https://newline.gent/). Hackers, makers, and curious minds gathered to share ideas, tools, experiments and a few beers.
I had a small contribution with a short [lecture-performance](https://0110.be/attachment/presentations/2025.05.newline-ghent/index.html) which covered [how to control your computer with a flute]( https://0110.be/posts/Making_a_flute_controlled_mouse). The lecture part covered the technical part of the build, the performance part included playing Flappy Bird with a flute. A third significant part of the talk — arguably the main focus — was devoted to bragging about the global attention the project received.
Other highlights of the Newline conference included talks on Home Assistant, 3D design, BTRFS and workshops that invited everyone to get involved.
Big thanks to the organizers and everyone who joined. I’m already looking forward to the next one!
---
## [Local TLS certificates with Caddy](https://0110.be/posts/Local_TLS_certificates_with_Caddy.md)
- Published: 2025-03-21T00:00:00Z
- Updated: 2025-04-15T12:51:11Z
- Author: Joren
- ID: 562
- Canonical: https://0110.be/posts/Local_TLS_certificates_with_Caddy
- Tags: [UGent](https://0110.be/tags/UGent.md)
This short guide will help you set up a local certificate using Caddy as the webserver to provide local TLS certificates to be able to develop websites immedately using HTTPS. Having a local HTTPS server in development can help with e.g. debugging CORS issues, accessing resources which require a HTTPS connection, or trying out analytics platforms.
#### 1. Configure your hosts file
If you want to use a domain name, you need to first add a line to `/etc/hosts` which, in this case, sets `localhost` to correspond to `example.com`.
```ruby
echo "127.0.0.1 example.com" | sudo tee -a /etc/hosts
```
#### 2. Configure Caddy
In a directory of your choosing, create a `Caddyfile` with the following content, it sets Caddy to automatically generate certificates on the fly for example.com or any other domain name. Perhaps you will need to trust the main Caddy certificate on first use:
```ruby
{
# Enable the internal CA
local_certs
}
example.com {
root * .
file_server
tls internal
}
```
#### 3. Create a test site
In the same directory, create an `index.html` file with contents similar or use your local web the following, or :
```ruby
Hello World!
```
#### 4. Start the Webserver
Still in the same directory as the `Caddyfile` and the `index.html` file, run the following command to start the Caddy web server: `caddy run`
#### 5. Trust the locally generated certificate
In macOS this means adding the [local caddy root certificate to your keychain](https://blog.lanzani.nl/2024/trust-local-caddy-certificates-on-macos/). It can be found here `/data/caddy/pki/authorities/local/root.crt` In other environments a similar step is needed.
#### 6. access the Test Site
Open your web browser and navigate to `https://example.com` to access the test site in the command line: `open https://example.com`. If you inspect the certificate it should be issued by the 'Caddy local authority'.
---
## [Powering low current electronics projects with power banks](https://0110.be/posts/Powering_low_current_electronics_projects_with_power_banks.md)
- Published: 2025-01-26T00:00:00Z
- Updated: 2025-02-01T10:13:55Z
- Author: Joren
- ID: 558
- Canonical: https://0110.be/posts/Powering_low_current_electronics_projects_with_power_banks
- Tags: [Code](https://0110.be/tags/Code.md), [Projecten](https://0110.be/tags/Projecten.md), [UGent](https://0110.be/tags/UGent.md)
Power banks have become a staple for charging smartphones, tablets, and other devices on the go. They seem ideal to power small microcontroller projects but, they often pose a problem for low-current applications. Most modern power banks include an auto-shutdown feature to conserve energy when they detect a current draw below a specific threshold, often around 50–200mA. The idea being that the power bank can shut off after charging a smartphone. However, if you rely on power banks to power DIY electronics projects or remote applications with low current draw, this auto-off feature can be a significant inconvenience.
To address this issue, consider using power banks designed with an “always-on” or “low-current” mode. These power banks are engineered to sustain power delivery even when the current draw is minimal. Look for models that explicitly mention support for low-power devices in their specifications. If replacing a power bank isn’t an option, you can add a small load resistor or a USB dummy load to artificially increase the current draw. It works, but feels wrong and dirty.
For a [previous electronics project](https://0110.be/posts/When_both_tech_and_nature_call%3A_a_DIY_motion_sensor_to_activate_birdsong) I bought a power bank randomly. After a bit of testing, I determined that the minimal power draw was around 150mA, so I added a resistor to increase current draw. Only afterwards did I check the [manual of the power bank](https://mojogear.eu/cdn/shop/files/Manual-MG-10.pdf?v=683883965702775870) and noticed, luckily, that there was a low-current mode. I removed the resistor and improved the battery life of the project considerably. If you want to power your DIY Arduino or electronics project, first check the manual of the power bank you want to use!
Edit: after further testing it seemed that the low current mode of this specific power bank still shuts down after a couple of hours. Your mileage may vary, and the main point of this post still holds: check the manual of your power bank. Eventually I went with a [solution designed for electronics projects](https://www.az-delivery.de/nl/products/battery-expansion-shield-18650-v3-inkl-usb-kabel).
---
## [When both tech and nature call: a DIY motion sensor to activate birdsong](https://0110.be/posts/When_both_tech_and_nature_call%3A_a_DIY_motion_sensor_to_activate_birdsong.md)
- Published: 2025-01-25T00:00:00Z
- Updated: 2025-01-26T20:01:27Z
- Author: Joren
- ID: 556
- Canonical: https://0110.be/posts/When_both_tech_and_nature_call%3A_a_DIY_motion_sensor_to_activate_birdsong
- Tags: [UGent](https://0110.be/tags/UGent.md)
There is this thing that [starts playing birdsong](https://duckduckgo.com/?q=zwitscherbox&ia=web) when it detects movement. It is ideal to connect to nature while nature calls. It is a good idea, executed well but it got me thinking: this can be made less reliable, more time consuming, more expensive, and with a shorter battery life. So I started working on a DIY version.
Vid: Playing birdsong when presence is detected with an ESP32 microcontroller .
The general idea is to start playing birdsong if someone is present in a necessary room. In addition to a few of electronics components the project needs birdsong recordings. Freesound is a great resource for all kinds of environmental sounds and has a [collection of birdsong](https://freesound.org/people/juskiddink/packs/3675/) which was used for this project.
For the electronics components the project needs a microcontroller and a way to detect presence. I had a laser ranging sensor lying around which measures distance but can be repurposed to detect presence in a small room: most of the time, the distance to an opposite wall is reported. If a smaller distance is measured it is probably due to a person being present. The other components:
* An[ ESP32-C6 based Sparkfun Thing Plus](https://docs.sparkfun.com/SparkFun_Thing_Plus_ESP32_C6/introduction/). It has a battery recharging circuit, SD card reader, and a Quic connector.
* A time-of-flight laser sensor to measure distance. I used a VL53L0X with a grove connector.
* An I2**S** Amplifier to drive a speaker. I used the MAX 98357A, it seems to do what it needs to do.
* A small speaker, salvaged from some other device
* A MicroSD card, to store some audio files
* A rechargeable LiPo battery, or [a power bank with a low-current mode](https://0110.be/posts/Powering_low_current_electronics_projects_with_power_banks)
As is often the case with builds like this, neither the software nor the hardware is challenging conceptually but, making hard and software cooperate is. Some pitfalls I encountered: the ESP32 C6 needs USB CDC set in the Arduino IDE, the non standard I2C GPIO pins. Getting the many I2S parameters right. Dealing with a nasty pop sound once audio started. A broken LiPo battery. Most of the fixes can be found in the Arduino code
I use a polling strategy to detect presence. A distance measurement is taken and then the ESP32 goes into a deep sleep until the next measurement. A sensor with the ability to wake up the microcontroller would be a better approach.
Once everything was installed it worked well enough — motion triggered a random birdsong, creating a soothing, natural vibe. It may be less practical than the off-the-shelf version but I did learn quite a lot more than I would have by simply filling in a form and providing payment details...
- [birhouse-static.webp](https://0110.be/files/attachments/556/birhouse-static.webp)
- [birhouse-example.mp4](https://0110.be/files/attachments/556/birhouse-example.mp4)
- [birdsong\_arduino.ino](https://0110.be/files/attachments/556/birdsong_arduino.ino)
- [birdhouse-static.jpg](https://0110.be/files/attachments/556/birdhouse-static.jpg)
---
## [The time an HTTP request takes to pass through a proxy, a proxy, a proxy, a proxy, ...](https://0110.be/posts/The_time_an_HTTP_request_takes_to_pass_through_a_proxy%2C_a_proxy%2C_a_proxy%2C_a_proxy%2C_....md)
- Published: 2025-01-16T00:00:00Z
- Updated: 2025-01-21T10:57:17Z
- Author: Joren
- ID: 557
- Canonical: https://0110.be/posts/The_time_an_HTTP_request_takes_to_pass_through_a_proxy%2C_a_proxy%2C_a_proxy%2C_a_proxy%2C_...
- Tags: [UGent](https://0110.be/tags/UGent.md)
A discussion at work led to the question how much time it takes for a HTTP request to pass through a HTTP proxy. This blog post deals with this question by measuring a request passing through a stupid amount of HTTP proxies.
```ruby
curl -s -o /dev/null -w "%{time_starttransfer}\n" http://localhost:2000
```
Fig: Measuring the time it takes to pass 500 proxies with Curl.
In modern development setups it is not uncommon that your HTTP request passes a few HTTP proxies before reaching a final server that actually handles the request. In our case there is a proxy which ensures an SSL certificate, which is forwarded to a proxy which automatically forwards requests to a docker container. A final HTTP proxy runs in the docker network that forwards the request to a webserver. A response follows the same way in reverse.
```ruby
#Caddyfile, to pass through 500 HTTP proxies
:2000 {
reverse_proxy localhost:2001
}
:2001 {
reverse_proxy localhost:2002
}
...
:2500 {
respond "Hello, proxy!"
}
```
Fig: Configuration to pass a HTTP request through many proxies. The final response is a simple text.
To measure the time it take to pass through a HTTP proxy, I wrote a small script to start 500 separate instances of the Caddy webserver configured as a HTTP/2 proxy. Then, I measure the time it takes to pass through all 500 of the HTTP proxies or only 490, 480,... which results in the graph below.
Fig: Time it takes to pass x amount of HTTP proxies. The y-axis represents the time taken (in seconds), and the x-axis indicates the number of HTTP proxies passed.
So each proxy pass takes about 0.4 milliseconds in one of the best cases, where requests are forwarded from and to localhost. Network overhead adds to that but assuming that interconnects are fast, adding a few HTTP proxies does not affect latency in a meaningful way. Of course it is best to evaluate your situation and measure.
- [proxy\_time\_graph.png](https://0110.be/files/attachments/557/proxy_time_graph.png)
- [measure.rb](https://0110.be/files/attachments/557/measure.rb)
- [script.rb](https://0110.be/files/attachments/557/script.rb)
---
## [Tasmota for custom ESP32 smart home devices](https://0110.be/posts/Tasmota_for_custom__ESP32_smart_home_devices.md)
- Published: 2025-01-03T00:00:00Z
- Updated: 2025-01-08T20:12:39Z
- Author: Joren
- ID: 555
- Canonical: https://0110.be/posts/Tasmota_for_custom__ESP32_smart_home_devices
- Tags: [Code](https://0110.be/tags/Code.md), [Projecten](https://0110.be/tags/Projecten.md), [UGent](https://0110.be/tags/UGent.md)
In my house, I have a few smart home features: to control ventilation, to open and close solar screens, and to switch a few smart sockets. Up until a couple of days ago, the ventilation and screen controllers operated using custom software running on an ESP32. However, configuring, maintaining, upgrading, and integrating with this custom software gradually became a headache.
Recently, I switched from custom software to Tasmota, an open-source smart home platform targeting ESP32 devices. Tasmota includes a web UI, flexible configuration options, OTA upgrades, and scripting features. The scripting functionality allows devices to be extended with additional commands, which is especially practical for controlling my solar screens. These screens use pulses to toggle between up-stop-down-stop states. By default, Tasmota only supports enabling or disabling a relay, not enabling it for a very brief period (e.g., 150 milliseconds). With a short ‘Berry’ script, such functionality is quickly added.
I appreciate the effort of the Tasmota team to lower the entry barrier for users. They provide ample documentation and a web installer, making setup straightforward. Simply connect your ESP32 via USB, flash it with Tasmota, and configure it—all from your browser. It’s a surprisingly simple process compared to installing a dedicated toolchain. While this might not be what Tim Berners-Lee envisioned 35 years ago, it certainly simplifies the user experience. Lowering the entry barrier even further, some manufacturers even offer smart home devices with Tasmota preinstalled, such as the Nous A1 smart sockets. Eternal september is here.
If you’re managing custom ESP32 smart home devices, consider switching to Tasmota. Its robust features, ease of setup, and active community support make it an excellent choice for both beginners and advanced users.
---
## [GhentCDH at the Faculty Research Day](https://0110.be/posts/GhentCDH_at_the_Faculty_Research_Day.md)
- Published: 2024-11-27T00:00:00Z
- Updated: 2024-11-27T10:07:51Z
- Author: Joren
- ID: 551
- Canonical: https://0110.be/posts/GhentCDH_at_the_Faculty_Research_Day
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
The [research day of the faculty of Arts and Philosophy of Ghent University](https://www.lwresearchday.ugent.be/) took place last November. The theme of the day was ‘*From Source to Understanding*’ and the program gave an overview of the breadth of research at our faculty with topics as logic, history, archeology, chemistry, geography, language studies, ... There were several contributions by our group: the Ghent Center for Digital Humanities. The contribution by me and my close colleagues [was a poster about a reusable text annotation](https://0110.be/files/attachments/551/poster_text_annotation.webp) building block.
Fig: Poster on a text annotation component.
At GhentCDH we support several text annotation projects and have extracted a text annotation component for reuse. The abstract reads:
> "*Text annotation is essential for analyzing ancient texts, identifying entities in texts, or documenting evolving grammar. There is a need for reusable annotation methods which copes with challenges such as overlapping annotations, filtering annotation types, and enabling large-scale collaboration and computational analysis on text annotation work.*
>
> *We present a reusable text annotation component built with TypeScript and Vue 3. It provides an intuitive interface for creating, visualizing, and editing annotations, it allows component users to enrich annotations with complex metadata, and facilitates flexible annotation filtering. This solution meets many needs of researchers in digital humanities and ancient language studies and will be used in several GhentCDH projects.*"
Get more info, try it out and use it in your project by checking the [text annotator source code repository](https://github.com/GhentCDH/vue_component_annotated_text).
---
## [Connecting two Bluetooth headsets to your Linux system: audio routing in PipeWire](https://0110.be/posts/Connecting_two_Bluetooth_headsets_to_your_Linux_system%3A_audio_routing_in_PipeWire.md)
- Published: 2024-10-23T00:00:00Z
- Updated: 2024-10-25T09:00:02Z
- Author: Joren
- ID: 552
- Canonical: https://0110.be/posts/Connecting_two_Bluetooth_headsets_to_your_Linux_system%3A_audio_routing_in_PipeWire
- Tags: [0110.be](https://0110.be/tags/0110.be.md), [UGent](https://0110.be/tags/UGent.md)
Imagine you want to stream a movie at home but also want to keep things quiet to avoid disturbing others. Evidently, this what headsets were invented for. Connecting one wireless Bluetooth headset is typically straightforward - aside from the occasional Bluetooth pairing issues. But what if you want to watch that movie with someone else, and you both want to use headsets? Connecting two Bluetooth headsets, or even combining wired and wireless headsets to share the same audio, isn’t as simple as it sounds. This blog post shows how to achieve this on modern Linux distributions.
Fig: Connecting an audio source - Spotify - to multiple output devices by using audio routing with PipeWire and `qpwgraph`.
During the last years, several Linux distributions have started to support the PipeWire audio server. It is even the default audio server in Debian 12 and Ubuntu 22.10. With PipeWire, managing audio devices has become much easier. PipeWire enables flexible audio setups and supports audio routing: sending out audio from a single source to several output devices. This is exactly what we need to stream audio to multiple headsets.
If you use PipeWire on your system, `qpwgraph` provides an intuitive graphical interface that lets you visualize and control audio routing. To connect multiple headsets:
1. First install `qpwgraph` e.g via `apt install qpwgraph`
1. Startup `qpwgraph` which should show your current audio routing graph.
1. Pair your Bluetooth headsets to your machine. They will appear in the audio routing graph once paired successfully.
1. Connect the audio source to your headsets by connecting 'wires' from your media player to the headsets.
I was surprised how robust audio has become on Linux and how easy and user friendly it is to set up even more complex audio / MIDI configurations. Give it a try!
---
## [Validity and reliability of peak tibial accelerations as real-time measure of impact loading during over-ground rearfoot running at different speeds](https://0110.be/posts/Validity_and_reliability_of_peak_tibial_accelerations_as_real-time_measure_of_impact_loading_during_over-ground_rearfoot_running_at_different_speeds.md)
- Published: 2024-10-01T00:00:00Z
- Updated: 2024-10-01T14:30:24Z
- Author: Joren
- ID: 550
- Canonical: https://0110.be/posts/Validity_and_reliability_of_peak_tibial_accelerations_as_real-time_measure_of_impact_loading_during_over-ground_rearfoot_running_at_different_speeds
- Tags: [Research papers](https://0110.be/tags/Research%20papers.md), [UGent](https://0110.be/tags/UGent.md)
The publication of this paper seemed an almost sisyphean task, but it is now finally in print after about four years since first submission.
All's well that ends well and it is well indeed: the paper contributes a fundamental insight around the resultant peak tibial acceleration (PTA) in forefoot running: contrary to what is often presumed, the resultant PTA is higher in forefoot running! The paper combines two separate experiments into a single analysis framework which ensures robustness in the finding. The conclusions of the article can be found below:
> ***Conclusions*** *Many coaches and practitioners presume that forefoot striking decreases impact severity and prevents overuse injuries; however, our data show that instructed and habitual forefoot strikes have greater resultant but not axial PTA than habitual rearfoot strikes in level running at a submaximal speed. The forefoot strikes had a sharp decrease in the antero-posterior velocity of the shank following touchdown and, therefore, a greater antero-posterior acceleration, which resulted in the greater resultant peak tibial acceleration compared to the rearfoot strikes. Conclusively, the foot strike pattern differently affected PTAs and should be taken into account when evaluating 3D impact severity in distance runners.*
My contribution to the paper was limited to technical development and support during the measurements at Ghent University. For the full paper, please read the publishers version of [Validity and reliability of peak tibial accelerations as real-time measure of impact loading during over-ground rearfoot running at different speeds](https://www.tandfonline.com/doi/full/10.1080/14763141.2024.2367619).
---
## [OnTracx product launch - a Ghent University sports-tech spin-off](https://0110.be/posts/OnTracx_product_launch_-_a_Ghent_University_sports-tech_spin-off.md)
- Published: 2024-04-24T00:00:00Z
- Updated: 2024-04-25T11:54:49Z
- Author: Joren
- ID: 544
- Canonical: https://0110.be/posts/OnTracx_product_launch_-_a_Ghent_University_sports-tech_spin-off
- Tags: [UGent](https://0110.be/tags/UGent.md)
Fig: OnTracx logo
A couple of days ago, [OnTracx](https://www.ontracx.com/) launched their first product: a system to measure impact during running with the aim to become *'The Future of injury-free running'*. Next to the launch event itself, OnTracx was featured in the [national](https://www.vrt.be/vrtnws/nl/2024/04/17/nieuwe-tracker-voor-belasting-te-meten-bij-lopen-of-joggen/) [media](https://www.tijd.be/ondernemen/technologie/slimme-sensor-van-gentse-start-up-ontracx-moet-komaf-maken-met-loopblessures/10541459.html) as well.
OnTracx is a Ghent University spin-off and their product is based on a couple of scientific studies. I had the chance to collaborate on some of these studies:
* Van den Berghe, P., Six, J., Gerlo, J., Leman, M., & De Clercq, D. (2019). [__Validity and reliability of peak tibial accelerations as real-time measure of impact loading during over-ground rearfoot running at different speeds__](https://pubmed.ncbi.nlm.nih.gov/30824234/). Journal of Biomechanics
* Van den Berghe, P., Lorenzoni, V., Derie, R., Six, J., Gerlo, J., Leman, M., & De Clercq, D. (2021). __Music-based biofeedback to reduce tibial shock in over-ground running: A proof-of-concept study__. Scientific reports
As is already clear from the title of the second paper: originally the idea was to use music-based biofeedback as a way to reduce impact. Unfortunately, this feature is not - yet? - present in the commercial project which focuses on the measurement and clearly reporting a proxy to mechanical load. This does make the message focused and is probably a good commercial move. I bought one of the sensors and already tested it out during a 5k-run. I was pleasantly surprised with the smooth on-boarding and the slick, well thought-out, user-friendly app.
Become part of the *'The Future of injury-free running'* and go and [get OnTracx](https://www.ontracx.com/)!
---
## [Making a flute controlled mouse](https://0110.be/posts/Making_a_flute_controlled_mouse.md)
- Published: 2024-04-22T00:00:00Z
- Updated: 2024-05-15T10:22:18Z
- Author: Joren
- ID: 539
- Canonical: https://0110.be/posts/Making_a_flute_controlled_mouse
- Tags: [Code](https://0110.be/tags/Code.md), [UGent](https://0110.be/tags/UGent.md)
There is something about surprising interfaces: clapping to switch on lights is more fun than a flipping a switch. [Pressing a panic-button to order a pizza](https://0110.be/posts/Order_Pizza_with_USB_Pizza_Button) is more fun than ordering via an app. Recently I came across [this surprising interface](https://www.reddit.com/r/JustGuysBeingDudes/comments/195gqnm/imagine_losing_to_this_dude/): a flute controlled mouse cursor for a first person shooter. I recognize a good idea when I see one, and immediately wanted replicate the idea and make it freely available. So I got to work:
Vid: a microcontroller controlling mouse movements based on pitch detection.
What do we need for **flute-based mouse**? First we need a way to determine if a note is being played and if a note is produced, we need to be able to determine which note is being played by the musician. Next, we need to hijack and control a cursor via the detected note and trigger a click event when a specific note is played. Finally we need to play a flute, preferably a recorder, to move the mouse cursor in an obviously superior and relaxed fashion. It is not strictly required to use a recorder but a recorder is [very much advised](https://www.youtube.com/watch?v=QuFTCirwmoM&list=PLhJfRNMFx-hX7NUhYaintwbFGMs6lmvmQ).
The note determination can be done by a fundamental frequency detector. A detector returns a frequency in Hertz and a confidence score which tells you how reliable the detection is. With some filtering, this is exactly what we need. If the frequency is close enough to a configured value, a note is detected. The confidence score tells us to either accept or ignore the detection. With this info it is possible to connect a note-detection to an action - like moving a cursor left or right, up or down.
Finally we need to move the mouse cursor. There are a few ways to do this.
## 🪈 An micro-controller-based solution - Pitch perfect pointer positioning - PiPePoPo
Fig: Flute-based web-browsing as envisioned by its developer.
A portable way to move a mouse cursor is to let a micro-controller impersonate as a standard mouse, a __'USB Human Interface Device'__. Once the micro-controller is attached via USB it registers as a mouse and allows to move the cursor and register click events. To build a flute-based mouse, the micro-controller then needs a microphone and a pitch estimator to finally send cursor events.
I based my project on an RP2040 - a [*micro-controller chip designed by Raspberry Pi*](https://www.raspberrypi.com/products/rp2040/specifications/) - since it offers a simple way to present itself to an operating system as a mouse. Just include `PluggableUSBHID.h` and `USBMouse.h` and use the Mouse API to control the mouse. For me it only behaved as a standard mouse if `Serial` is not used at the same time: in other words the dual USB profile does not seem to work reliably.
Sending mouse events from your code looks, for example, like ` Mouse.move(-4, 7)` to move the mouse minus four units in the horizontal and seven units in the vertical direction. Click events have a similarly straightforward API. The RP2040 also has a built-in microphone, which makes it ideal for audio applications, or so it seems.
Unfortunately, the RP2040 chip performs poorly for computationally heavy audio processing workloads. Such applications need to perform many floating point operations per second, but the RP2040 lacks a hardware floating point unit (FPU) which makes it [relatively slow](https://github.com/tana/pico_float_bench). When attempting to run a pitch-detection algorithm, the RP2040 was too slow to run the algorithm in real-time. After profiling the pitch estimation algorithm there was a clear place where most float operations occurred. Replacing those with much quicker fixed point operations makes the algorithm faster than real-time and usable on the RP2040.lt
To give a sens of the difference in speed between fixed point and floating point operations on the RP2040: with the default arduino build process, a million floating point operations take over 883 000 microseconds, a million fixed point operations take 8 microseconds. Fixed point operations are around 5 orders of magnitude faster!
I have named released the code under the name [Pitch perfect pointer positioning or PiPePoPo](https://github.com/JorenSix/PiPePoPo) for short. For the details, please do check the source code repository. Perhaps the most intresting, reusable component is the [ANSI C implementation of the YIN pitch estimator](https://github.com/JorenSix/PiPePoPo/blob/main/RP2040/PiPePoPo/yin_fixed.c), both in floating point and sped up with fixed point operations.
## 🪈 A browser extension - Pitch perfect pointer positioning - PiPePoPo
The hardware based solution works reliably but, evidently, it needs a piece of hardware. To make sure everybody can enjoy a solution in software is provided in this section in the form of a chrome browser extension.
Moving a cursor is not possible in a browser: if a pointer location could be modified it would open a whole range of possibilities for abuse. A surprisingly easy workaround, however, is to hide the actual cursor and show a replacement cursor-like icon. This fake cursor can be moved programmatically. With the position of this fake cursor known, a click event can be triggered and result in, for example, following a link.
To take this idea to its logical next step, I implemented a chrome browser plug-in for flute-based web-browsing. I also relased this on GitHub under the Pitch perfect Pointer Positioning or PiPePoPo brand. Check the installation instructions in the [PiPePoPo repository](https://github.com/JorenSix/PiPePoPo). Perhaps most of interest is how audio processing is handled by a Web Audio API Audio Worklet.
Vid: Controlling a cursor via a browser extension.
Join the flute-based web-browsing revolution today and experience web browsing like never before and install PiPePoPo.
I am not sure how but PiPePoPo was also featured on [HackADay](https://hackaday.com/2024/04/24/flute-now-included-on-list-of-human-interface-devices) and the official [Arduino Blog](https://blog.arduino.cc/2024/04/28/this-arduino-nano-rp2040-connect-powered-flute-blows-your-pcs-mouse-away/).
---
## [Measuring rain water tank level with an Arduino](https://0110.be/posts/Measuring_rain_water_tank_level_with_an_Arduino.md)
- Published: 2024-03-28T00:00:00Z
- Updated: 2024-03-29T10:47:07Z
- Author: Joren
- ID: 543
- Canonical: https://0110.be/posts/Measuring_rain_water_tank_level_with_an_Arduino
- Tags: [UGent](https://0110.be/tags/UGent.md)
Fig: Submersible water level meter.
Due to the climate crisis, long droughts are becoming more common in Western Europe during the summers. Conversely, during the winters, it seems that there is more and more extreme rainfall. With [record breaking](https://www.meteo.be/nl/klimaat/klimaat-van-belgie/klimatologisch-overzicht/2024/februari) droughts and rainfall, it is essential that enough rainwater buffering capacity is available. As a private citizen this means installing a large rain water tank - perhaps larger than outdated models suggest - and using the captured water effectively, if at all possible.
Fig: Submersible water level meter.
To effectively use rain-water, it helps to have an easy way to view the water level in the tank. This makes clear when to conserve water or when a pump might end up running dry and overheat. So I wanted to install **a water level measurement device in my rain water tank**.
My first attempt used sonar. This sends out a sound-wave which reflects on the water surface. The sonar measures the time it takes for the echo to return. This setup is finicky in an echoy tank but I managed to get it working. However, after couple of months the sonar stopped working in the damp environment.
Next I tried a optical, infra-red-based setup: the idea was to time the infra-red reflection on the water. After installation it appeared that water is transparent for infra-red. I basically measured the position of the floor of my tank. I took comfort in the fact that this measurement remained stable but had to look for a third option.
I finally became aware of sturdy, submersible pressure sensors which are designed for water level measurements. One of those is the QDY30A sensor, which is available in many versions but there is one which takes five volts as input and returns a 0 - 3.3V output: ideal to use with about any modern micro-controller. The sensor can be connected via a long cable. This helps to keep the Arduino in a dry place indoors. After recording a few measurements and the corresponding sensor depth, the sensor seems to show a very linear response: with two references, converting a sensor value to a depth in millimeters is doable. The readings ended up on a website and are [visualized via a SVG sparkline](https://alexplescan.com/posts/2023/07/08/easy-svg-sparklines/).
Fig: Rain water level visualization for a few days, measured every 15 minutes. Going from 221cm to 197cm.
With the Arduino code attached you should be able to get going. Next to reading and converting a sensor value, it also includes reading the median of several values to add some smoothing. The sensor is read on request: only when a serial message arrives a measurement is done.
---
## [Offloading authentication and user management to Keycloak - A minimal example with Nuxt and Litestar](https://0110.be/posts/Offloading_authentication_and_user_management_to_Keycloak_-_A_minimal_example_with_Nuxt_and_Litestar.md)
- Published: 2024-03-13T00:00:00Z
- Updated: 2024-03-19T09:13:26Z
- Author: Joren
- ID: 542
- Canonical: https://0110.be/posts/Offloading_authentication_and_user_management_to_Keycloak_-_A_minimal_example_with_Nuxt_and_Litestar
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [UGent](https://0110.be/tags/UGent.md)
At the [Ghent Center for Digital Humanities](https://www.ghentcdh.ugent.be/) we provide software services for researchers. Think about, for example, annotation platforms for ancient texts or collaborative databases with geographically referenced historical data. Each of those services need some kind of authentication and user management: some parts of the service might be public, some only accessible for researchers at Ghent University and other parts need to be accessible e.g. to external researchers or collaborators. Providing authentication, login-flows and user management for each and every service quickly becomes tedious and, frankly, boring.
We went looking for a solution and stumbled on [Keycloak](https://www.keycloak.org/). Keycloak is an open source __Identity and Access Management__ system and is able to either authenticate users itself or pass through authenticate to other authentication providers like LDAP, GitHub, OAuth accounts, or others. It avoids the need to setup application-specific user management system. Flows like 'forget password', 'verify email', 'two factor authentication' are not part of your application itself but are provided by Keycloak. Leaving the developer to focus on application specific tasks.
Video: An API call to a protected back-end first fails. After authentication and receiving a JWT token, the back-end call succeeds. The authenticated session is then shown in Keycloak.
Integration with Keycloak is a bit of work and not straightforward. As part of trying out Keycloak I have created a [minimal working example of a front-end / back-end system which uses Keycloak for authentication](https://github.com/GhentCDH/nuxt-keycloak-jwt-auth/). To get full access to the back-end API the user first needs a valid JWT-token provided by Keycloak. The flow can be seen in the video above. The dockerized environment can perhaps serve as inspiration for similar setups. Please do try out the [dockerized minimal working example](https://github.com/GhentCDH/nuxt-keycloak-jwt-auth/) and see if Keycloak can fit your use-case.
---
## [3D modeling with ChatGPT - Solidified ephemerality](https://0110.be/posts/3D_modeling_with_ChatGPT_-_Solidified_ephemerality.md)
- Published: 2024-02-21T00:00:00Z
- Updated: 2025-12-10T13:04:12Z
- Author: Joren
- ID: 541
- Canonical: https://0110.be/posts/3D_modeling_with_ChatGPT_-_Solidified_ephemerality
- Tags: [Code](https://0110.be/tags/Code.md), [UGent](https://0110.be/tags/UGent.md)
I have asked ChatGPT to generate 3D models. ChatGPT can not generate 3D models directly but 3D models can generated via intermediary [OpenSCAD](https://openscad.org/news.html) scripts: OpenSCAD provides a scripting language to describe objects which can be combined to form 3D models. ChatGPT understands the syntax of this scripting language and generates perfectly cromulent scripts. I have asked two versions of ChatGPT to generate a 3D model of a house, a cat, a stick figure, a chair and a tree. The results are interesting...
The models immediately make the difference between ChatGPT 3.5 Turbo and ChatGPT 4.0 clear: 4.0 generates much better models with, at least, recognizable elements: a chair has four legs, a cat has a head and a tail. It is impressive that reasonable 3D models are generated but there is still room for improvement: proportions are not respected and elements are not always connected. Anyway, if __the 3D-models can be seen as a way to visualize code quality__, then 4.0 is a clear improvement and it makes me curious about future ChatGPT versions. It also made me reflect on a couple of aspects of LLMs in general.
Fig: a black box generating 3D models.
* **ephemerality** The response of a LLM to a prompt is ephemeral: the same prompt causes a different response depending on context, randomness and the position of heavenly bodies - or so it seems. Traditional software systems follow a strict set of clear rules and provide deterministic, predictable and reliable results. The inverse is true for LLMs which takes some getting used to. As a user, an LLM is effectively a [vantablack](https://en.wikipedia.org/wiki/Vantablack) box - there is no way to know why a certain response was given instead of another.
* **Updates** LLMs services - and SaaS in general - have an additional feature which makes them even more unpredictable: updates to systems can happen without notice. After a recent unannounced update, for example, [ChatGPT 4 started to produce gibberish](https://status.openai.com/incidents/ssg8fh7sfyz3). This adds another layer to the already uncontrollable and ephemeral nature of responses to LLM prompts.
To counter the ephemeral quality of prompt responses, I have 3D printed the generated [3D models](https://0110.be/files/attachments/541/ChatGPT3D.zip). Some pictures can be found below. I find that these physical, tangible, immutable objects provide a comforting counterbalance to the digital, ephemeral nature of LLM responses. Additionally, it highlights the absurdity of the generated models.
There are other ways to solidify ephemerality: [crochet patterns](https://www.theguardian.com/technology/2023/feb/26/chatgpt-generated-crochet-pattern-results), juggling patterns, guitar tablature, music notation all have some kind of structured text representation which LLMs can generate and which can have a physical representation. I would encourage people to bring prompt responses to the physical world: it really makes the - current - limitations of LLMs very clear.
---
## [Containerized development - Dockerized Python database development](https://0110.be/posts/Containerized_development_-_Dockerized_Python_database_development.md)
- Published: 2024-01-22T00:00:00Z
- Updated: 2024-01-22T10:31:50Z
- Author: Joren
- ID: 540
- Canonical: https://0110.be/posts/Containerized_development_-_Dockerized_Python_database_development
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [UGent](https://0110.be/tags/UGent.md)
Fig: Containerized development.
At the [Ghent Center for Digital Humanities](https://www.ghentcdh.ugent.be/) (GhentCDH) we offer IT-services mainly for researchers in the Humanities at Ghent University. The services range from internal collaborative research tools to publicly facing science communication platforms. Technically, it is a mix of off the shelve software with or without modifications and custom solutions using several technical stacks. It is a challenge to keep these services running, secure and up-to-date for years with a limited budget.
In an attempt to make maintenance of these services more manageable we are in the process of [containerizing](https://en.wikipedia.org/wiki/Containerization_(computing)) our software. __Running software in containers has advantages__. One of the advantages is a guaranteed consistency across environments. Also, isolated software containers can be beneficial for security and stability. It also allows one to run different versions of a stack on the same server without running into compatibility problems.
Next to running software in containers, __development in containers also has advantages__. It allows you to switch projects easily without needing to install dependencies - e.g a specific database system version - directly on a development machine. The main advantage I see is that containerization promotes developer hygiene. Stereotypically, developers do not have the best hygiene and can use any available help. Containerization forces developers to think about separation of code and configuration, code and data and it forces to be explicit about dependencies and environmental assumptions.
The main disadvantage is that some configuration is needed to get the containers running and that there is a small performance penalty. The following might help with that first part.
## Dockerized Python database development
To put the theory to the test my colleagues and I put together a [GitHub repository with a dockerized Python development setup](https://github.com/GhentCDH/Python-db-dev). It shows interaction between Python and a PostgreSQL database. The database system runs in a container and the development environment is also kept in a container. Both containers are started with `docker compose` and configured via a `.env` file.
The stack uses a recent Python version, [PDM](https://pdm-project.org/latest/) to resolve Python dependencies and SQLAlchemy to interact with the PostgreSQL database. The VS code editor allows developers to __run and debug software in a container__. The video below shows the startup procedure and setting a breakpoint in some Python code.
Vid: Starting a database server and development container. Running and debugging Python code in a container.
Note that this is just an example setup, your setup might look quite different. You might need a different stack, use a different container environment (e.g. podman) or IDE but the principle of container based development could stay the same.
I have put off using containers for quite a while and I am quite a late convert, but now that I am doing more technical work in a small team I do see the advantages of an easy-to-set up, controlled, containerized development with explicitly defined dependencies. If you have no experience with containers yet, I would encourage you to at least __try container based development__ out and see where it could help you!
---
## [OnTracx launch - a Ghent University sports-tech spin-off](https://0110.be/posts/OnTracx_launch_-_a_Ghent_University_sports-tech_spin-off.md)
- Published: 2024-01-10T00:00:00Z
- Updated: 2024-01-10T10:57:56Z
- Author: Joren
- ID: 515
- Canonical: https://0110.be/posts/OnTracx_launch_-_a_Ghent_University_sports-tech_spin-off
- Tags: [UGent](https://0110.be/tags/UGent.md)
Fig: OnTracx logo
A couple of months ago, [OnTracx, a Ghent University sports-tech spin-off](https://www.ontracx.com/) launched with the *'dream of a world where every runner can stay injury-free'*. That dream is based on a firmly grounded [interdisciplinary research project](https://0110.be/posts/Low_impact_runner%3A_a_music_based_bio-feedback_system), which I was fortunate to contributed to. The research project - headed by the UGent sports science department - developed a music-based bio-feedback system to reduce footfall shock while running with the aim to lower common running-related injury risk. I fondly remember soldering and programing the first cluncky prototypes, now already eight years ago!
In my role, I contributed to several key papers that form the foundation of OnTracx. Notably, the 'validity and reliability' paper, which has become the most cited work in my academic portfolio, which at least indicates academic interest. The main author of the paper is now doing a post-doc in Harvard, so he must have been doing something right! Additionally, I am also recognized as co-inventor on a patent related to the system.
* Van den Berghe, P., Six, J., Gerlo, J., Leman, M., & De Clercq, D. (2019). [__Validity and reliability of peak tibial accelerations as real-time measure of impact loading during over-ground rearfoot running at different speeds__](https://pubmed.ncbi.nlm.nih.gov/30824234/). Journal of Biomechanics
* Van den Berghe, P., Lorenzoni, V., Derie, R., Six, J., Gerlo, J., Leman, M., & De Clercq, D. (2021). __Music-based biofeedback to reduce tibial shock in over-ground running: A proof-of-concept study__. Scientific reports
Fig: schema of the low impact runner research system. Foot-fall impact is measured with wearable sensors and music-based feedback is given to the runner with the aim to avoid high impact.
The journey from research to commercial realization is always thrilling. As OnTracx steps into the market, I am filled with hope and anticipation for its success, mirroring and potentially exceeding the fruitful research track.
For more, read the [spin-off story of OnTracx, the solution for lower impact running](https://www.victoris.be/the-spin-off-story-of-ontracx-the-solution-for-lower-impact-running/) or join the [beta program on the OnTracx website](http://ontracx.com) and help with *'dream of a world where every runner can stay injury-free'*.
---
## [Printing a part of the world - a 3D-printed cityscape](https://0110.be/posts/Printing_a_part_of_the_world_-_a_3D-printed_cityscape.md)
- Published: 2024-01-09T00:00:00Z
- Updated: 2025-11-13T22:55:02Z
- Author: Joren
- ID: 537
- Canonical: https://0110.be/posts/Printing_a_part_of_the_world_-_a_3D-printed_cityscape
- Tags: [0110.be](https://0110.be/tags/0110.be.md), [GhentCDH](https://0110.be/tags/GhentCDH.md), [UGent](https://0110.be/tags/UGent.md)
Fig: 3D printing your part of the world.
My ex-girlfriend and current wife likes maps. While looking for a gift for the new-years I got the idea to give her a 3D map of the nearby [historic city center of Ghent with its three iconic towers](https://earth.google.com/web/@51.05385689,3.72537111,16.45165093a,593.4748548d,35y,19.92318437h,59.99406466t,359.99999999r/data=OgMKATA). I have a 3D printer at home but still need to find a printable 3D model of Ghent.
Luckily, a couple of days ago a piece of software appeared to [capture Google Earth tiles -cubes- into a single 3D file](https://github.com/OmarShehata/google-earth-as-gltf). There you can select an area of interest via google maps and download a GLTF file which captures the landscape in 3D. The software needs an API key which can be requested via the Google Developer tools.
After downloading a GLTF file, the 3D model needs to be made 3D-printable. There are online [GLTF to STL converters](https://products.aspose.app/3d/conversion/gltf-to-stl) but a bit of care needs to be taken to end up with an actually **printable** STL. My selected area of interest only has slight height differences in the landscape which are handled by placing the STL file on a base which compensates for these differences. Your 3D slicer can also generate structure to support inclinations in the landscape.
The 3D model generated by Google Earth is quite noisy and can contain floating parts and holes. It may be needed to edit the STL mesh directly. Selecting a slightly shifted area of interest may also solve problems with the edges of the print: take care to chop less buildings in two.
Have fun printing your own piece of the world!
Fig: a 3D model for the Ghent city center visualized with an Three.js STL viewer.
---
[Older posts](https://0110.be/tags/UGent.md?page=1)
Fig: Gemini imagining the age of AI exploits. 
A couple of former colleagues have just published the article [Robot-mediated haptic feedback outperforms vision in violin duo coordination ](https://www.science.org/doi/10.1126/scirobotics.aeb1901) in Science Robotics. The article is about providing guidance to violin players with an exoskeleton. Congratulations Alexandra, Mark and Canan!
It is the result of an European research project in which I was involved in only at the start. I did, however, also contribute to the study in a small but crucial way. During the experiment, the exoskeletons suddenly stopped working. I was asked to have a look and see if there was something to be done. I was a bit hesitant to go near these unique, expensive prototypes with a soldering iron but, after a couple of tense minutes and fixing some - easy to access - connections the arms came back alive. The experiment could continue and everybody started clapping and cheering. This is at least how I remember it. Perhaps that last part is not entirely accurate. Anyhow, I made it into the acknowledgments; thanks Ola.
> **Abstract** *Joint actions among humans rely on the integration of multiple sensory modalities, most notably auditory and visual cues, which support explicit communication between partners. However, haptic feedback provides a direct, implicit channel for sensorimotor communication, and its contribution to fine motor coordination in joint actions remains largely unexplored. Here, we demonstrate that haptic communication, rendered through bidirectionally coupled wearable robots, outperforms traditional auditory-visual feedback in a complex and challenging real-life joint action: ensemble violin performance.
First, we developed a pair of two–degree-of-freedom upper-limb exoskeletons capable of transparently following violinists’ natural movements and rendering viscoelastic torques proportional to the joint angular deviation between the partners. Then, we designed a within-subject experiment with 20 violin duos performing a musical piece under four sensory feedback conditions: auditory (A), auditory-visual (AV), auditory-haptic (AH), and auditory-visual-haptic (AVH), across two tempi (72 and 100 beats per minute). Despite the musicians being unfamiliar with the robot-mediated haptic feedback and unaware of the bidirectional connection between them, haptic feedback (AH and AVH) substantially enhanced spatiotemporal coordination and dynamic musical alignment compared with the extensively trained auditory-visual feedback (A and AV). The multisensory feedback condition AVH yielded the highest scores across all measures. Our findings demonstrate that haptic feedback can support fine motor coordination in violin duo performance more effectively than visual cues, particularly for professional musicians, because of its implicit and embodied nature, and that it can be effectively delivered via wearable robots, expanding the paradigms of human-human sensorimotor interactions.*
---
## [Guest lecture on \`Music Information Retrieval - Opportunities for digital musicology'](https://0110.be/posts/Guest_lecture_on_%60Music_Information_Retrieval_-_Opportunities_for_digital_musicology%27.md)
- Published: 2025-11-13T00:00:00Z
- Updated: 2025-11-13T11:19:36Z
- Author: Joren
- ID: 572
- Canonical: https://0110.be/posts/Guest_lecture_on_%60Music_Information_Retrieval_-_Opportunities_for_digital_musicology%27
- Tags: [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
This morning I gave a guest lecture introducing the field of music information retrieval to musicology students at Ghent University. Next to the more general MIR intro, two specific topics are fleshed out: duplicate detection and pitch patterns in music around the world. Two topic I have been working on before.
The presentation has the form of an interactive website via [reveal.js](https://revealjs.com/). It features a couple of slides which are full-blown applications or have an interactive sound visualization component. Please do try out the slides and check the [Music Information Retrieval - Opportunities for digital musicology](https://0110.be/attachment/cors/2025.11.MIR-Intro/index.html) presentation or try it below.
- [MIR\_intro.pdf](https://0110.be/files/attachments/572/MIR_intro.pdf)
---
## [USB MIDI support on ESP32: the ESP32-S3](https://0110.be/posts/USB_MIDI_support_on_ESP32%3A_the_ESP32-S3.md)
- Published: 2025-11-13T00:00:00Z
- Updated: 2025-11-13T20:57:46Z
- Author: Joren
- ID: 563
- Canonical: https://0110.be/posts/USB_MIDI_support_on_ESP32%3A_the_ESP32-S3
- Tags: [UGent](https://0110.be/tags/UGent.md)
If you’re considering adding USB MIDI functionality to a music project with an ESP32, it’s crucial to choose the right variant of the chip. The ESP32-S3 is currently the go-to model for USB-related tasks thanks to its native USB capabilities. Unlike other ESP32 models, the S3 can handle USB MIDI directly without the need for additional components, making it an ideal choice for integrating MIDI devices into your setup. For more details on using USB MIDI with the ESP32-S3, check out the [ESP32USBMIDI project](https://github.com/esp32beans/ESP32USBMIDI).
When combined with the ESP32-S3’s built-in WiFi and support for OSC (Open Sound Control) or ESP Now, the platform becomes very versatile for music controllers or applications. A quick tip: after flashing your device in MIDI mode, the serial is not available any more. Flashing the device also becomes impossible. If you need to reflash your device, the process is simple: just hold down the Boot button and press Reset.
Another short tip: for troubleshooting and logging, the [mot project](https://github.com/JorenSix/mot) provides useful tools for debugging OSC or MIDI messages. The support is currently [stil in flux](https://github.com/espressif/arduino-esp32/issues/10978) but do not make the mistake I made and do not try to do MIDI with a ESP C3 series.
---
## [Pompernikkel - the Interactive speaking pumpkin 🎃](https://0110.be/posts/Pompernikkel_-_the_Interactive_speaking_pumpkin_%F0%9F%8E%83.md)
- Published: 2025-11-03T00:00:00Z
- Updated: 2025-11-14T09:34:42Z
- Author: Joren
- ID: 570
- Canonical: https://0110.be/posts/Pompernikkel_-_the_Interactive_speaking_pumpkin_%F0%9F%8E%83
- Tags: [0110.be](https://0110.be/tags/0110.be.md), [Projecten](https://0110.be/tags/Projecten.md), [UGent](https://0110.be/tags/UGent.md)
The last few halloweens I have been building one-off interactive installations for visiting trick-or-treaters. I did not document the build of last year, but the year before I built an [interactive door bell with a jump scare door projection](https://0110.be/posts/Doorbell_triggered_Halloween_window_projection). This year I was trying to take it easy but my son came up with the idea of doing something with a talking pumpkin. I mumbled something about feasibility so he promptly invited all his friends to come over on Halloween to talk to a pumpkin. So I got to work and tried to build something. This blog post documents this build.
A talking pumkin needs a few functions. It needs to understand kids talking in Dutch, it needs to be able to respond with a somewhat logical respons and ideally have a memory about previous interactions. It also needs a way to do turn-taking: indicating who is speaking and listening. It also needs a face and a name. For the name we quickly settled on Pompernikkel.
For the face I tried a few interactive visualisations: a 3D implementation with three.js and a shader based approach but eventually setteled on an approach of using an SVG and CSS animations to make the face come alive. This approach makes it doable to control animations with javascript since animating a part of the pumkin means adding or removing a css class. See below for the result
Last Friday, I had the pleasure of facilitating a hands-on workshop in Luxembourg as part of [MuTechLab workshop series](https://www.uni.lu/fhse-en/research-projects/mutechlab/), organized by [Luc Nijs](https://www.uni.lu/fhse-en/people/luc-nijs/) at the University of Luxembourg. Together with Bart Moens from [XRHIL](https://xrhil.ugent.be) and [IPEM](https://www.ugent.be/lw/kunstwetenschappen/ipem/en), we presented a system to control musical parameters with body movement.
MuTechLab is a series of workshops for music teachers who wish to dive into the world of music technology. Funded by the Luxembourgish National Research Fund (FNR, PSP-Classic), the initiative brings together educators eager to explore how technology can enhance music education and creative practice.
### What we built and presented
During the workshop, participants got hands-on experience with the [EMI-Kit](https://github.com/IPEM/EMI-kit) (Embodied Music Interface Kit) – an open-source, low-cost system that allows musicians to control Digital Audio Workstation (DAW) parameters through body movement.
The EMI-Kit consists of:
- **A wearable sensor device** (M5StickC Plus2) that captures body orientation and gestures
- **A receiver unit** (M5Stack STAMP S3A) that converts sensor data to MIDI messages
Unlike expensive commercial alternatives, EMI-Kit is fully open source, customizable, and designed specifically for creative music practice and embodied music interaction practice and research.
### The Experience
Teachers experimented with mapping natural body movements – pitch, yaw, roll, and tap gestures – to various musical parameters in their DAWs. The low-latency wireless system made it possible to move and control sound, opening up new possibilities for expressive musical performance and pedagogy.
### Learn More
Interested in exploring embodied music interaction yourself? Check out:
- [MuTechLab Project Page](https://www.uni.lu/fhse-en/research-projects/mutechlab/)
- [EMI-Kit on GitHub](https://github.com/IPEM/EMI-kit)
The EMI-Kit project as-is is a demonstrator to inspire educators to embrace these tools and imagine new ways of teaching and creating music. The EMI-Kit as a platform can - with some additional programming - be a good basis to control musical parameters using various sensors. Have fun with checking out the EMI-Kit.
---
## [MIDI and OSC tools improvements - MIDI processing and mDNS support](https://0110.be/posts/MIDI_and_OSC_tools_improvements__-_MIDI_processing_and_mDNS_support.md)
- Published: 2025-10-02T00:00:00Z
- Updated: 2025-10-06T13:54:28Z
- Author: Joren
- ID: 566
- Canonical: https://0110.be/posts/MIDI_and_OSC_tools_improvements__-_MIDI_processing_and_mDNS_support
- Tags: [Code](https://0110.be/tags/Code.md), [Music Information Retrieval](https://0110.be/tags/Music%20Information%20Retrieval.md), [UGent](https://0110.be/tags/UGent.md)
I've just pushed some updates to [mot](https://github.com/JorenSix/mot) — a command-line application for working with OSC and MIDI messages. My LLM tells me that these are exciting updates but I am not entirely sure that this is the case. Let me know if this ticks your box and seek professional help.
### 1. Scriptable MIDI Processor via Lua
I have implemented a **MIDI processor** that lets you transform, filter, and generate MIDI messages using [Lua](https://www.lua.org/about.html) scripts.
**Why is this useful?** MIDI processors act as middlemen between your input devices and output destinations.You can do the following on incoming MIDI messages:
- **Transform** - Transpose notes, generate chords, map velocity curves
- **Filter** - Block unwanted messages - channels - or select specific ranges
- **Route** - Send different notes to different channel
- **Generate** - Create complex patterns from simple input
The processor reads incoming MIDI from a physical device, processes it through your Lua script, and outputs the modified messages to a virtual MIDI port that your DAW or synth can receive. Some examples:
```ruby
# Generate chords from single notes
mot midi_processor --script scripts/chord_generator.lua 0 6666
# Transpose notes up by one octave
mot midi_processor --script scripts/example_processor.lua 0 6666
```
### 2. Network Discovery via mDNS
OSC receivers now **advertise themselves on the network** using mDNS/Bonjour with the `_osc._udp` service type.
This makes mot compatible with the [EMI-kit](https://github.com/IPEM/EMI-kit) — the Embodied Music Interface Kit developed at IPEM, Ghent University. OSC-enabled devices can automatically discover mot receivers on your network, eliminating manual configuration if the OSC sources add this functionality.
### Get started
Installation via Rust's cargo:
```ruby
git clone https://github.com/JorenSix/mot.git
cd mot
cargo install --path .
mot midi_processor -h
```
Check out the [mot repository](https://github.com/JorenSix/mot) for full documentation and example Lua scripts!
---
## [Newline.gent - A yearly hacker conference](https://0110.be/posts/Newline.gent_-_A_yearly_hacker_conference.md)
- Published: 2025-05-24T00:00:00Z
- Updated: 2025-06-03T13:53:12Z
- Author: Joren
- ID: 565
- Canonical: https://0110.be/posts/Newline.gent_-_A_yearly_hacker_conference
- Tags: [Hackerspace Ghent](https://0110.be/tags/Hackerspace%20Ghent.md), [UGent](https://0110.be/tags/UGent.md)
This weekend the - more-or-less - yearly conference of [Hackerspace Ghent](https://hackerspace.gent/) took place: [Newline.gent](https://newline.gent/). Hackers, makers, and curious minds gathered to share ideas, tools, experiments and a few beers.
I had a small contribution with a short [lecture-performance](https://0110.be/attachment/presentations/2025.05.newline-ghent/index.html) which covered [how to control your computer with a flute]( https://0110.be/posts/Making_a_flute_controlled_mouse). The lecture part covered the technical part of the build, the performance part included playing Flappy Bird with a flute. A third significant part of the talk — arguably the main focus — was devoted to bragging about the global attention the project received.
Other highlights of the Newline conference included talks on Home Assistant, 3D design, BTRFS and workshops that invited everyone to get involved.
Big thanks to the organizers and everyone who joined. I’m already looking forward to the next one!
---
## [Local TLS certificates with Caddy](https://0110.be/posts/Local_TLS_certificates_with_Caddy.md)
- Published: 2025-03-21T00:00:00Z
- Updated: 2025-04-15T12:51:11Z
- Author: Joren
- ID: 562
- Canonical: https://0110.be/posts/Local_TLS_certificates_with_Caddy
- Tags: [UGent](https://0110.be/tags/UGent.md)
This short guide will help you set up a local certificate using Caddy as the webserver to provide local TLS certificates to be able to develop websites immedately using HTTPS. Having a local HTTPS server in development can help with e.g. debugging CORS issues, accessing resources which require a HTTPS connection, or trying out analytics platforms.
#### 1. Configure your hosts file
If you want to use a domain name, you need to first add a line to `/etc/hosts` which, in this case, sets `localhost` to correspond to `example.com`.
```ruby
echo "127.0.0.1 example.com" | sudo tee -a /etc/hosts
```
#### 2. Configure Caddy
In a directory of your choosing, create a `Caddyfile` with the following content, it sets Caddy to automatically generate certificates on the fly for example.com or any other domain name. Perhaps you will need to trust the main Caddy certificate on first use:
```ruby
{
# Enable the internal CA
local_certs
}
example.com {
root * .
file_server
tls internal
}
```
#### 3. Create a test site
In the same directory, create an `index.html` file with contents similar or use your local web the following, or :
```ruby
Power banks have become a staple for charging smartphones, tablets, and other devices on the go. They seem ideal to power small microcontroller projects but, they often pose a problem for low-current applications. Most modern power banks include an auto-shutdown feature to conserve energy when they detect a current draw below a specific threshold, often around 50–200mA. The idea being that the power bank can shut off after charging a smartphone. However, if you rely on power banks to power DIY electronics projects or remote applications with low current draw, this auto-off feature can be a significant inconvenience.
To address this issue, consider using power banks designed with an “always-on” or “low-current” mode. These power banks are engineered to sustain power delivery even when the current draw is minimal. Look for models that explicitly mention support for low-power devices in their specifications. If replacing a power bank isn’t an option, you can add a small load resistor or a USB dummy load to artificially increase the current draw. It works, but feels wrong and dirty.
For a [previous electronics project](https://0110.be/posts/When_both_tech_and_nature_call%3A_a_DIY_motion_sensor_to_activate_birdsong) I bought a power bank randomly. After a bit of testing, I determined that the minimal power draw was around 150mA, so I added a resistor to increase current draw. Only afterwards did I check the [manual of the power bank](https://mojogear.eu/cdn/shop/files/Manual-MG-10.pdf?v=683883965702775870) and noticed, luckily, that there was a low-current mode. I removed the resistor and improved the battery life of the project considerably. If you want to power your DIY Arduino or electronics project, first check the manual of the power bank you want to use!
Edit: after further testing it seemed that the low current mode of this specific power bank still shuts down after a couple of hours. Your mileage may vary, and the main point of this post still holds: check the manual of your power bank. Eventually I went with a [solution designed for electronics projects](https://www.az-delivery.de/nl/products/battery-expansion-shield-18650-v3-inkl-usb-kabel).
---
## [When both tech and nature call: a DIY motion sensor to activate birdsong](https://0110.be/posts/When_both_tech_and_nature_call%3A_a_DIY_motion_sensor_to_activate_birdsong.md)
- Published: 2025-01-25T00:00:00Z
- Updated: 2025-01-26T20:01:27Z
- Author: Joren
- ID: 556
- Canonical: https://0110.be/posts/When_both_tech_and_nature_call%3A_a_DIY_motion_sensor_to_activate_birdsong
- Tags: [UGent](https://0110.be/tags/UGent.md)
There is this thing that [starts playing birdsong](https://duckduckgo.com/?q=zwitscherbox&ia=web) when it detects movement. It is ideal to connect to nature while nature calls. It is a good idea, executed well but it got me thinking: this can be made less reliable, more time consuming, more expensive, and with a shorter battery life. So I started working on a DIY version.
In my house, I have a few smart home features: to control ventilation, to open and close solar screens, and to switch a few smart sockets. Up until a couple of days ago, the ventilation and screen controllers operated using custom software running on an ESP32. However, configuring, maintaining, upgrading, and integrating with this custom software gradually became a headache.
Recently, I switched from custom software to Tasmota, an open-source smart home platform targeting ESP32 devices. Tasmota includes a web UI, flexible configuration options, OTA upgrades, and scripting features. The scripting functionality allows devices to be extended with additional commands, which is especially practical for controlling my solar screens. These screens use pulses to toggle between up-stop-down-stop states. By default, Tasmota only supports enabling or disabling a relay, not enabling it for a very brief period (e.g., 150 milliseconds). With a short ‘Berry’ script, such functionality is quickly added.
I appreciate the effort of the Tasmota team to lower the entry barrier for users. They provide ample documentation and a web installer, making setup straightforward. Simply connect your ESP32 via USB, flash it with Tasmota, and configure it—all from your browser. It’s a surprisingly simple process compared to installing a dedicated toolchain. While this might not be what Tim Berners-Lee envisioned 35 years ago, it certainly simplifies the user experience. Lowering the entry barrier even further, some manufacturers even offer smart home devices with Tasmota preinstalled, such as the Nous A1 smart sockets. Eternal september is here.
If you’re managing custom ESP32 smart home devices, consider switching to Tasmota. Its robust features, ease of setup, and active community support make it an excellent choice for both beginners and advanced users.
---
## [GhentCDH at the Faculty Research Day](https://0110.be/posts/GhentCDH_at_the_Faculty_Research_Day.md)
- Published: 2024-11-27T00:00:00Z
- Updated: 2024-11-27T10:07:51Z
- Author: Joren
- ID: 551
- Canonical: https://0110.be/posts/GhentCDH_at_the_Faculty_Research_Day
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
The [research day of the faculty of Arts and Philosophy of Ghent University](https://www.lwresearchday.ugent.be/) took place last November. The theme of the day was ‘*From Source to Understanding*’ and the program gave an overview of the breadth of research at our faculty with topics as logic, history, archeology, chemistry, geography, language studies, ... There were several contributions by our group: the Ghent Center for Digital Humanities. The contribution by me and my close colleagues [was a poster about a reusable text annotation](https://0110.be/files/attachments/551/poster_text_annotation.webp) building block.
Fig: a black box generating 3D models.
