Forem: IsmaelMartinez

Making Data Visualisations Audible

IsmaelMartinez — Tue, 06 Jan 2026 18:15:57 +0000

Originally published on Medium

A 10-year-old hackathon idea finally comes to life

About 10 years ago, I attended a Web Audio API hackathon, and left with an idea of a side project: what if blind users could “hear” data visualisations?

Charts are everywhere. Sales dashboards, stock prices, COVID statistics, climate data. For sighted users, a quick glance reveals trends, outliers, and patterns. But for the 2.2 billion people with vision impairments worldwide, these visualisations are essentially invisible walls.

Screen readers typically announce that a chart exists, or read values sequentially. That instant understanding that visualisations provide is lost.

Life got busy, and that hackathon idea sat in my notes for a decade, until now. With the help of AI pair programming, I was able to turn that decade-old idea into a working prototype in a fraction of the time.

Introducing sound3fy

sound3fy is an open-source library that adds sonification to D3.js visualisations. One line of code makes many charts audible:

d3.selectAll(".bar").sonify({ pitch: "value" });

It works with existing D3.js charts. No rewrites. No special data formats.

sound3fy is not intended to replace tables or screen readers, but to complement them by restoring some of the rapid, high-level pattern recognition that sighted users get from charts.

How sound3fy works

Keyboard navigation: Arrow keys to explore individual data points
Screen reader support: ARIA live regions announce values
Pitch mapping: Higher data values play higher notes
Stereo panning: Position maps to left/right audio channels
Musical scales: Notes quantized to pleasant scales like pentatonic or major

Try it yourself

Live Demo (interactive sonified charts)

The demo includes bar charts, line charts, and scatter plots. Try closing your eyes and pressing Play. Can you tell if sales are increasing or decreasing?

Why sonification?

Research shows that humans are particularly good at detecting patterns through sound. Rising pitch for trends, rhythm for regularity, and stereo positioning for spatial relationships.

Studies of sonification tools suggest that blind users can understand trends and comparisons in ways much closer to how sighted users read charts.

Recent research backs this up. A 2024 study from UIUC found that combining sonification with other modalities helps blind users interpret statistical charts with high accuracy.

Prior work

Sonification for accessibility isn’t new. Highcharts has offered a sonification module for years, and tools like TwoTone let anyone turn data into music without code.

Research tools like MAIDR have explored multimodal approaches combining sound with braille and natural audio.

sound3fy aims to bring this capability to the D3.js ecosystem, where many custom visualisations live but accessibility tooling is sparse. Chart2Music is a valid alternative, especially if you aren’t using D3.js for your graphs.

Technical design

sound3fy uses the Web Audio API for low-latency sound generation. Key design decisions include:

Musical scales: Raw frequency mapping sounds harsh. Quantizing to pentatonic scales makes the audio pleasant while preserving data relationships.
D3.js plugin architecture: It should work with any existing D3.js visualisation. No need to rebuild your charts.
Accessibility-first: Full keyboard navigation, ARIA attributes, focus management, and screen reader announcements are built in.

Looking for feedback

This is an early prototype, and I need feedback, especially from blind and low-vision users. I want to make sure this is genuinely useful, not just well intentioned.

Does the sonification help you understand data?
Is the keyboard navigation intuitive?
What is confusing or missing?

Hopefully it helps bridge that gap on accessibility. If it doesn’t, that’s still useful learning. I hope it sparks a conversation about how we can do better.

GitHub: https://github.com/IsmaelMartinez/sound3fy
Install: npm install sound3fy

If you work in accessibility, data visualisation, or know someone who might benefit from this tool, I would love to hear from you.

Automating Kibana Visualisations Generation

IsmaelMartinez — Thu, 28 Nov 2019 11:23:44 +0000

As a developer, when I find myself doing the same task over and over, I take a step back and consider automation. That is the well known DRY (Don’t Repeat Yourself) principle.

By taking the effort, you might end up fixing other issues along the way.

Keeping visualisations and code changes in sync, it’s been one of the most annoying things since I started working with microservices, AWS Lambdas and Kibana.

Because of that, I have created logger-to-kibana. An open source project that tries to help solve that problem.

The idea

logger-to-kibana aims to parse your source code and generates basic, but useful, visualisations.

You should be able to just stick it into your deployment pipeline and that should keep those basic visualisations up to date.

There are plenty of tools out there to ship and format your log messages. This tool assumes your logs are in Elastic/Kibana.

Let’s now look into an example:

Example

This piece of code:

import logging
from datetime import datetime

LOG = logging.getLogger()


def lambda_handler(event, context):
    LOG.info(‘lambda_handler called’)
    return {’message’: datetime.now()}

Assuming that you have a message in Kibana with a message object and the content as “lambda_handler called”.

logger-to-kibana will find the message and generate the following visualisation:

Visualisations are grouped depending on the sub-folder, filename and function.

Finally, it generates a dashboard with all the visualisations.

Configuration

You need to follow the next steps in order to get this working.

Install logger-to-kibana from pipy

pip install logger-to-kibana

Then run:

logger-to-kibana process_generate_and_send -f <folder>

That will process all the files under <folder>app/src/**/*.py, parsing them using RegExp looking for the different log messages in the files.

Check the README.md#how-does-it-work to find more about how does it work. You can also find details about how to change it for your own needs.

As pointed out before, it splits/group the messages by sub-folder, filename and then function, and generates a metric visualisation for each group.

The dashboard with all visualisations generated will have the top folder name (that typically is the project name).

Closing notes

The main goal was to help identify issues in the code by having visualisations, but it’s already bringing a few extras:

Identifying poor, or even duplicated, log messages
Improving consistency of log messages
Synchronising code and visualisations
Documenting the logs generated by your code

Ideally, the program will choose the best visualisation depending on the amount of data (and maybe type), but implementing that might take a while.

I will take the aproach of generating visualisations in other systems like cloudwatch and/or graphana. If that happens maybe I need to change the name to logger-to-graph or something like that.

What next

I will start by explaining the build process. As I have mentioned at the top, I hate repetition and try to embrace automation. Lets start with the CI/CD and how I have archived, in my opinion, a fairly good level of automation in that front.

But I will take a wee break as I have already done enough for today. More to come!

You can also pop along and help contribute into the project. ;)

IsmaelMartinez / logger-to-kibana

Parse loggers in your code and generate a kibana visualisation with them

logger-to-kibana

This project is inteded to generate view from the log messages encountered.

The python executable can be found in https://pypi.org/project/logger-to-kibana/

You will need to install the dependences by running

pip install -r requirements.txt

To get the programs help just type:

python main.py

This returns:

  Usage: main.py [OPTIONS] COMMAND [ARGS]...

  Process the file provided according to conditions

Options:
  --help  Show this message and exit.

Commands:
  pommands:
  process                    Process the folder
  process_and_generate       Process the folder and generate visualization
  process_generate_and_send  Process the folder, generate visualization and
                             send

I have created a dev.to series explaining how this project works and any learning that I have taken from doing so. You can find it in https://dev.to/ismaelmartinez/setting-up-my-first-opensource-python-project-4k1o

Default settings

The default settings can be found in the settings.ini file. You can provide a different settings file by specifying it as an environment variable LOGGER_TO_KIBANA_CONFIG

commands

The current available commands are:

process

Process a folder and…

View on GitHub

Setting up my first OpenSource Python project

IsmaelMartinez — Thu, 28 Nov 2019 11:23:30 +0000

In this series, I will explain what I did to set-up my first PyPi project. It’s a bit of a double whammy, it should help people sorting that out, and check with other developer what I did oddly.

This is also my first python project of my own. I have learned lots but I understand there is plenty of room for error and improvements (hopefully more of the later)

I will start by explaining the project itself, and the reason for it. You should not need to know it, but it should allow to understand the reasons behind it.

The project is logger-to-kibana and encapsulates the main idea of trying to automate everything.

It will be too long for a single post so I decided to make it a series.

It also allows me time to continue improving the process and adding extra functionalities to logger-to-kibana project.

I hope this helps and encourage people to set-up Open Source projects that solves those annoying repetitive tasks.

As always, I welcome constructive feedback. This is also my first dev post and most of the tools used are new to me. That is one of the reasons to play with them ;)

Let me know what you think about it. Lets get started with the project itself.