DEV Community: Sam Sheridan

I Needed to Test Laptop Keyboards Properly, So I Built a 47 MB Bootable Tool

Sam Sheridan — Sat, 19 Sep 2026 20:47:16 +0000

I refurbish and repair quite a few laptops. One of the less interesting but important parts of that work is checking every key on the keyboard.

A keyboard can appear perfectly fine until you discover that one letter, function key or modifier does not work. If you do not test every key deliberately, it is surprisingly easy to miss.

There are plenty of keyboard-testing websites, but they assume the laptop already has a working operating system, browser and network connection. There are also bootable hardware-testing tools, but many are much larger than they need to be or include dozens of features that are irrelevant when all I want to test is the keyboard and mouse.

I wanted something I could put on a USB drive, boot on practically any PC and use immediately.

So I built KbdCheck.

A deliberately small tool

KbdCheck is a minimal bootable Linux environment based on Arch Linux.

The entire ISO is around 47 MB. It does not install anything, modify the existing operating system or need an internet connection. It boots directly from a USB drive into the testing interface.

The display shows a complete keyboard. As each key is pressed, the corresponding key is highlighted. This makes it easy to work methodically across the keyboard and spot anything that is missing, stuck or producing the wrong input.

It also includes a simple mouse test, so the buttons, scroll wheel and pointer movement can be checked at the same time.

That is essentially the whole tool. It does one job and boots quickly enough that using it does not become a job in itself.

Why make it bootable?

Running independently of the installed operating system removes quite a few variables.

A laptop may have no operating system installed yet. Windows may be damaged, locked or halfway through its initial setup. A key-mapping problem, accessibility setting or driver issue can also make a software fault look like a hardware fault.

Booting a known environment gives me a consistent test on every machine. If a key fails in KbdCheck, I can be reasonably confident that I am looking at a keyboard problem rather than an operating-system problem.

It is also useful before fitting a replacement keyboard. I can test the new part properly before finishing the repair and handing the laptop back.

Built because I needed it

This was not an attempt to produce another general-purpose diagnostic suite.

I needed a small keyboard-testing tool for my own workshop. I could not find one that worked quite how I wanted, so I wrote it.

It has already justified its existence by finding a faulty U key on a laptop I was refurbishing. The keyboard otherwise appeared to work normally, which is precisely why checking every key matters.

That is the sort of problem small tools are good at solving. They do not need hundreds of features. They just need to remove one repetitive annoyance and produce a clear answer.

Using KbdCheck

Download the ISO and write it to a USB drive using a tool such as Rufus, Balena Etcher or dd.

Boot the computer from the USB drive and the keyboard tester will start automatically. Work through the keys and confirm that each one registers on screen. The mouse test is available from the same interface.

KbdCheck currently requires Secure Boot to be disabled, as the image is not signed for Secure Boot. Nothing is installed on the computer, and the existing disks are not required for the test.

The ISO download is accompanied by a SHA-256 checksum so its integrity can be verified before use.

Free to use

I built KbdCheck for my own workshop, but there was little point keeping the finished tool to myself.

It is free to download and use. If you repair, refurbish or regularly prepare laptops, it may save you a little time as well.

Download KbdCheck from "kbdcheck.com" (https://kbdcheck.com/).

Shrink Your Font Awesome Bundle by 98% with Automatic Icon Subsetting

Sam Sheridan — Thu, 18 Sep 2025 01:59:57 +0000

Tired of shipping 800KB+ of Font Awesome fonts when you only use a handful of icons? Here's a tool that automatically detects which icons you're actually using and creates tiny subset fonts.

The Problem

Font Awesome is brilliant, but it comes with a performance cost. When you include the full FA webfonts, browsers download the entire font file even if you only use a few icons. That means:

FA6 Solid: ~345KB
FA6 Duotone: ~458KB
Total payload: Often over 1MB including CSS

Your users pay this cost on every page load, especially painful on mobile connections.

The Solution: fa-subset

I built fa-subset to solve this exact problem. It's a Python tool that:

Scans your codebase to find all fa-* classes you actually use
Detects Font Awesome styles (solid, duotone, brands, etc.) automatically
Creates tiny subset fonts containing only the icons you need
Generates optimised CSS that references the subset fonts

Real Results

Here's what happened on a production site:

Before:  803 KB fonts + CSS (~1.29 MB total)
After:   14.5 KB fonts + CSS (~0.50 MB total)
Savings: 98.2% reduction in font size, 61% total payload reduction

Key Features

✅ Works with FA5 & FA6 (all styles: solid, regular, light, thin, duotone, brands, sharp)

✅ Handles complex selectors like .fa-duotone.fa-house:after

✅ Duotone support with proper dual codepoint handling

✅ Multi-pack subsetting (separate optimised fonts per style)

✅ Dry-run reports with detailed breakdown

✅ Works with minified CSS and any file extensions

Quick Start

Prerequisites

pip install fonttools

Basic Usage

Dry run to see what will be optimised:

python3 bin/fa-subset.py \
  --src ./src ./templates \
  --ext .html .php .twig .js \
  --pack solid:css=./css/fontawesome.min.css,font=./fonts/fa-solid-900.ttf \
  --pack duotone:css=./css/duotone.min.css,font=./fonts/fa-duotone-900.ttf \
  --out ./optimised \
  --dry-run

Generate subset fonts (remove --dry-run):

python3 bin/fa-subset.py \
  --src ./src ./templates \
  --ext .html .php .twig .js \
  --pack solid:css=./css/fontawesome.min.css,font=./fonts/fa-solid-900.ttf \
  --pack duotone:css=./css/duotone.min.css,font=./fonts/fa-duotone-900.ttf \
  --out ./optimised

Include the optimised CSS:

<link rel="stylesheet" href="/optimised/solid/fontawesome.solid.subset.min.css">
<link rel="stylesheet" href="/optimised/duotone/fontawesome.duotone.subset.min.css">

Smart Detection

The tool intelligently handles:

Mixed content:

<i class="fa-solid fa-house"></i>           <!-- Solid pack -->
<i class="fa-duotone fa-user"></i>          <!-- Duotone pack -->
<i class="fas fa-search"></i>               <!-- FA5 alias → solid -->
<span class="fa-brands fa-github"></span>   <!-- Brands pack -->

Complex selectors in CSS:

.fa-duotone.fa-house:after { content: "\f015\f015"; } /* Duotone dual codepoints */
.custom-icon.fa-solid.fa-star { /* Custom styling */ }

Dynamic content with proper fallbacks:

// The tool finds icons even in JS template strings
const iconHtml = `<i class="fa-solid fa-${iconName}"></i>`;

Advanced Features

JSON Reports for CI/CD

--report-json ./report.json --strict-styles

Perfect for CI pipelines to catch style conflicts:

{
  "conflicts": [
    {"file": "nav.html", "line": 42, "icon": "user", "styles": ["solid", "duotone"]}
  ],
  "packs": {
    "solid": {"icons_found": ["house", "user"], "codepoints": ["U+F015", "U+F007"]}
  }
}

Composer Integration

Add these scripts to your composer.json:

{
  "scripts": {
    "fa-analyse": "python3 bin/fa-subset.py --src ./src --pack solid:css=./css/fontawesome.min.css,font=./fonts/fa-solid-900.ttf --out ./optimised --dry-run",
    "fa-optimise": "python3 bin/fa-subset.py --src ./src --pack solid:css=./css/fontawesome.min.css,font=./fonts/fa-solid-900.ttf --out ./optimised"
  }
}

Then simply run:

composer fa-analyse   # See what will be optimised
composer fa-optimise  # Generate the subset fonts

Performance Impact

The difference is dramatic:

Before (Full FA6):

First Contentful Paint: slower due to font loading
Lighthouse Performance Score: penalised for large resources
Mobile users: significant bandwidth usage

After (Subset):

Faster initial page loads
Better Lighthouse scores
Happier mobile users
Reduced CDN costs

Best Practices

Cache aggressively: Serve subset fonts with long Cache-Control headers
Use compression: Enable Brotli/gzip on your server
One style per icon: Don't mix fa-solid and fa-duotone on the same element
Run in CI: Use --strict-styles to catch conflicts early

Common Use Cases

WordPress themes:

--src ./wp-content/themes/mytheme --ext .php

React/Vue projects:

--src ./src --ext .js .jsx .vue .tsx

Laravel applications:

--src ./resources/views ./app --ext .blade.php .php

Troubleshooting

Icons show as squares?

Ensure you're including the subset CSS, not the original
Check the Network tab - the subset .woff2 should load
Verify CORS headers if serving from a CDN

"No icon rules found in CSS"?

Use all.min.css or per-style CSS files (e.g., solid.min.css)
The CSS must contain icon mappings, not just variables

Why This Matters

Font optimisation often gets overlooked, but it's one of the highest-impact performance wins you can achieve. With fa-subset, you get:

Massive file size reductions (90%+ typical)
Faster page loads especially on mobile
Better Core Web Vitals scores
Reduced bandwidth costs
Zero maintenance once set up

Get Started

Repository: fa-subset on GitHub

Licence: BSD-2-Clause (bring your own FA licence)

The tool includes comprehensive documentation, examples, and CI integration guides. Give it a try on your next project - your users (and Lighthouse scores) will thank you!

Made by Sam Sheridan at Sheridan Internet. Not affiliated with Font Awesome/Fonticons Inc.

fontawesome #performance #webdev #optimization #fonts #css #python #opensource