RanzLappen

The Digital Services Act and Trusted Flaggers: EU Power Expansion, NGO Subsidies, and the Difficulty of Stopping New Rules

2026-07-06T00:00:00+00:00

Introduction

The European Union’s Digital Services Act (DSA) establishes the Trusted Flaggers system to speed up action against illegal online content.^[1] While framed around user safety, the mechanism forms part of a recurring pattern in EU digital regulation: the creation of layered administrative powers, frequent involvement of publicly supported civil society organizations, and legislative dynamics that make it structurally difficult to halt or substantially redirect rules once they gain institutional momentum.

This article explores these dimensions through the lens of Trusted Flaggers, drawing on the framework’s design and implementation experience.

What Are Trusted Flaggers Under the DSA?

Under Article 22 of the DSA (Regulation (EU) 2022/2065), Trusted Flaggers are entities (not individuals) granted special status by a Member State’s Digital Services Coordinator (DSC).^[2] Once designated, online platforms must give their notices on illegal content priority treatment and process them without undue delay.^[3]

To receive status, an entity must show:^[1]

Specific expertise and competence in detecting, identifying, and notifying illegal content.
Independence from any online platform providers.
Operation in a diligent, accurate, and objective manner.

The designation applies across the EU.^[1] Platforms can trigger reviews if a flagger submits a significant number of insufficiently precise or inaccurate notices, potentially leading to suspension or revocation by the DSC after an investigation.^[3] Trusted Flaggers must publish annual public reports on their activities, and the European Commission maintains an updated public database of all designated entities.^[1]

EU Power Expansion Through Regulation

The DSA and related instruments significantly expand the EU’s regulatory and enforcement footprint in the digital space. Very Large Online Platforms must conduct systemic risk assessments covering not only illegal content but also broader issues such as disinformation, manipulation of electoral processes, and negative effects on civic discourse.^[2],[4] Non-compliance can result in fines reaching up to 6% of global annual turnover, enforced primarily by the European Commission for the largest platforms.^[4]

Trusted Flaggers add another layer: DSCs hold the power to designate entities that then receive mandatory priority treatment from platforms operating EU-wide.^[1] This creates a chain of authority running from national coordinators through designated organizations to private platforms, backed by substantial financial penalties. Critics argue that such structures concentrate influence in administrative bodies with relatively few immediate checks from elected institutions or affected users once the rules are in force.^[7]

Subsidizing NGOs as Enforcers and Policy Actors

Many organizations active in content flagging or related policy areas receive funding through EU programmes. The network of national Safer Internet Centres — which typically combine an awareness centre, a helpline, and an INHOPE-member hotline focused on child sexual abuse material — is co-funded by the European Commission under the Digital Europe Programme, within the Better Internet for Kids (BIK+) strategy.^[5],[6]

This funding dynamic raises questions about independence and feedback loops. Organizations that receive public grants for child protection or hate speech work can later apply for Trusted Flagger status, gaining prioritized access to platform moderation systems. Academic analysis of Article 22 has flagged funding sources and independence verification as open questions in the designation process — independence from platform providers is a criterion DSCs must verify, and questions about who finances a flagger feed directly into that assessment.^[7] Civil society groups themselves have raised concerns about designation standards, including how independence should be determined and whether law enforcement bodies or profit-seeking industry organizations should be eligible at all.^[8],[9]

Critics see this as a self-reinforcing cycle in which publicly resourced actors help shape and then enforce regulatory priorities. While official criteria emphasize independence and objectivity, the practical reliance on EU funding sources for operational capacity can align incentives with broader institutional goals.

How New Rules Advance With Limited Effective Opposition

Most major EU digital regulations, including the DSA, follow the ordinary legislative procedure. The European Commission initiates proposals. The European Parliament and Council then negotiate positions, frequently through informal trilogue meetings involving representatives of all three institutions to reach compromises quickly — the route by which the large majority of EU legislative files are now agreed.^[10]

Council decisions generally require a qualified majority: at least 55% of Member States (15 of 27) representing at least 65% of the EU population, with a blocking minority needing at least four Member States.^[11] Once political agreement is reached in trilogue and formally endorsed, the process moves toward adoption with limited remaining opportunities for fundamental reversal.

In practice, this structure means that once a proposal gains significant institutional backing and moves past early stages, sustained opposition from individual Member States, civil society, or platforms faces high procedural hurdles. Trilogue negotiations are often conducted with limited public transparency — a long-standing criticism raised by digital rights groups and examined by the European Ombudsman, whose 2016 strategic inquiry pushed the institutions toward publishing more trilogue documents.^[10],[12] The combination of high compliance costs for platforms and coordinated enforcement across the single market further entrenches rules after adoption. Changing course later typically requires entirely new legislative proposals subject to the same dynamics.

The DSA itself illustrates the timeline: proposed by the Commission in December 2020, politically agreed in trilogue in April 2022, formally adopted in October 2022, and fully applicable from 17 February 2024.^[13] A typical path for a regulation like this looks as follows:

Commission publishes proposal.
Parliament and Council conduct first readings and develop positions.
Informal trilogue negotiations seek compromise.
Political agreement reached.
Formal adoption by Parliament and Council.
Publication in the Official Journal.
Phased entry into application (with transitional periods).

Once past the trilogue stage, reversing or substantially diluting core elements becomes rare.

Official Safeguards and Counter-Perspectives

Proponents and official sources emphasize several built-in protections within the Trusted Flaggers framework. Entities must publish detailed annual reports covering the number and types of notices submitted and the actions taken by platforms.^[1] The Commission maintains a public, machine-readable database of all awarded statuses.^[1] DSCs can investigate and suspend or revoke status if a flagger submits a significant number of insufficiently precise or inaccurate notices, following information from platforms or on their own initiative.^[3] Platforms retain final responsibility for deciding whether content is illegal and must provide statements of reasons to users.^[2]

In May 2026, the Commission published draft guidelines under Article 22(8) aimed at clarifying eligibility, strengthening safeguards, and supporting consistent application, with a targeted consultation running to July 2026 and adoption planned for the second half of the year.^[14] Supporters argue that the system targets only illegal content (as defined by law), improves efficiency over ordinary user notices, and includes revocation mechanisms that earlier voluntary flagging arrangements lacked. They stress that these features, combined with transparency requirements, provide meaningful accountability while advancing legitimate safety objectives.

Child Safety Narratives and Broader Control

Child protection, especially against child sexual abuse material, serves as one of the strongest and most widely accepted justifications for enhanced flagging mechanisms. Hotlines and networks focused on this issue have long-standing operations that align closely with DSA goals.^[5]

At the same time, the child safety imperative sits within a wider DSA architecture that addresses systemic risks on large platforms, including disinformation and other “harmful” content categories.^[4] Some observers argue that the moral weight of protecting children provides political cover for expanding regulatory infrastructure and designation powers into more contested domains of speech and information. The prioritized notice channel can accelerate outcomes across a broader range of content once the system is operational.

Surveillance Structures and Historical Parallels

Critics have drawn parallels between the Trusted Flaggers ecosystem and historical models of monitored public discourse. The structure involves state-coordinated designation of reporting entities, mandatory platform responses to prioritized notices, and broader platform obligations to monitor systemic risks. This creates layered observation and enforcement channels with administrative rather than purely judicial gatekeeping in many instances — a tension academic commentary has examined specifically in relation to internet users’ freedom of expression.^[7]

When combined with the involvement of publicly funded organizations and the structural difficulty of unwinding the underlying rules, some commentators see echoes of systems that relied on networks of approved reporters and indirect control over expression. Supporters reject these analogies, pointing to the narrow focus on illegal content, transparency obligations, and revocation procedures as key distinctions.

Key Takeaways

The DSA Trusted Flaggers system creates prioritized notice channels backed by significant enforcement powers for non-compliant platforms.
EU digital regulation frequently expands administrative designation and oversight authority while relying on networks that include publicly funded civil society actors.
Funding relationships between EU programmes and NGOs/hotlines active in content areas can create practical dependencies and incentive alignments.
The ordinary legislative procedure, with its reliance on trilogues and qualified majority voting, makes it procedurally difficult to halt or fundamentally redirect major regulatory packages once they advance past early negotiation stages.
Official safeguards such as annual reporting, public databases, and revocation mechanisms exist, yet critics maintain that the overall architecture still concentrates influence in ways that are hard to reverse.
Child safety provides a compelling core rationale, but the surrounding systemic risk framework allows the mechanism to influence wider areas of content governance.

Conclusion

The Trusted Flaggers framework under the Digital Services Act reflects recurring features of EU digital policy: the layering of regulatory power through designation mechanisms, the integration of publicly supported organizations into enforcement roles, and legislative processes that favor forward momentum over easy reversal. While child protection and the removal of clearly illegal content remain important objectives with broad support, the structural design and implementation incentives continue to generate debate about accountability, scope creep, and the balance between safety and open expression.

Implementation so far has been slower and more uneven than the framework’s ambitions suggested — designations trickled in during the first year of full application, prompting observers to ask where all the Trusted Flaggers were.^[15] As more entities receive status and enforcement actions accumulate, the practical consequences of these design choices will become clearer. The pattern of creating durable regulatory architectures with limited off-ramps suggests that early scrutiny of new proposals remains one of the more effective points of influence.

Sources

European Commission — Trusted flaggers under the Digital Services Act (DSA). Official policy page: designation criteria, EU-wide validity, annual reports, and the public database of designated entities.
Regulation (EU) 2022/2065 (Digital Services Act) — full text, EUR-Lex. Article 22 (trusted flaggers), Article 17 (statements of reasons), Articles 34–35 (systemic risk assessment and mitigation).
Article 22, the Digital Services Act — annotated provision text. Priority treatment of notices, reporting obligations, and the suspension/revocation mechanism for imprecise notices.
European Commission — The enforcement framework under the Digital Services Act. Commission enforcement powers over VLOPs/VLOSEs and fines of up to 6% of global annual turnover.
European Commission — Safer Internet Centres. National centres (awareness centre, helpline, INHOPE-member hotline) co-funded under the Digital Europe Programme.
European Commission — A European strategy for a better internet for kids (BIK+).
Jacob van de Kerkhof (2025). "Article 22 Digital Services Act: Building trust with trusted flaggers?" Internet Policy Review 14(1). Academic examination of independence, funding, transparency, and freedom-of-expression concerns. DOI: 10.14763/2025.1.1828.
Center for Democracy & Technology (2023). Trusted Flaggers in the DSA: Challenges and Opportunities.
EDRi (2023). How to protect fundamental rights when appointing Trusted Flaggers (guide for Digital Services Coordinators, PDF).
European Parliamentary Research Service (2021). Understanding trilogue — informal tripartite meetings to reach provisional agreement on legislative files (PDF). Includes the European Ombudsman's strategic inquiry into trilogue transparency.
Council of the European Union — Qualified majority voting. 55% of Member States (15 of 27) representing at least 65% of the EU population; blocking minority requires at least four Member States.
EDRi — Trilogues: the system that undermines EU democracy and transparency.
Council of the European Union — Digital Services Act (policy page and legislative timeline).
European Commission (2026). Draft Commission guidelines on trusted flaggers (Article 22(8) DSA). Published 29 May 2026; targeted consultation open until 10 July 2026.
TechPolicy.Press — Europe's Digital Services Act: Where Are All The Trusted Flaggers? On the slow pace of designations during early implementation.

tools.ranzlappen.com: A Collection of Fast, Browser-Based Developer Utilities

2026-06-04T00:00:00+00:00

Introduction

tools.ranzlappen.com is a clean, fast collection of practical browser-based utilities designed for developers, designers, and power users. Instead of installing multiple apps or relying on bloated online services, you get a growing set of focused tools that run directly in your browser — most with zero server round-trips.

The project source lives at Ranzlappen/tools^[1] and is deployed on two complementary platforms: GitHub Pages for the static site and Vercel for the API layer. It is MIT licensed and complies with repo-standards v3 at full compliance.

All 15 Tools

The dashboard currently offers 15 tools across a clean tile-based interface with instant previews:

Tool	What it does
JSON Formatter	Pretty-print, minify, and validate JSON entirely in the browser
Color Picker	Pick colors, convert between HEX, RGB, HSL, OKLCH, and more; WCAG contrast checking in real time
Regex Tester & Builder	Live match highlighting with a guided pattern generator alongside
Markdown Preview	Real-time GitHub Flavored Markdown rendering; imports HTML, CSV, JSON, DOCX, XLSX, PDF, PPTX for conversion
Multi-Encoder	Convert text between Base64, Hex, URL encoding, Binary, and ASCII
JWT Decoder	Inspect JWT header, payload, and signature locally — nothing leaves the page
UUID & Hash Generator	Generate UUID v4/v7 and MD5, SHA-1, SHA-256, SHA-512 hashes on demand
QR & Barcode Generator	All 1D and 2D symbologies with design control and multi-format export
Video Studio	Trim, reverse, resize, crop, rotate, color-grade, and re-encode; export video, GIF, PNG frames, or audio — entirely in-browser via `ffmpeg.wasm`^[2]
OG Image Studio	Design and generate 1200×630 social media cards via a Vercel edge function
Flipper GUI Studio	Visual drag-and-drop editor for Flipper Zero / Momentum apps with C code export
Metadata Studio	Inspect, edit, or strip EXIF, ID3, PDF, Office, and ZIP metadata from files
MIUI Theme Studio	Build and export custom Xiaomi MIUI/HyperOS themes (.mtz) with wallpapers, icons, fonts, and system colors
YouTube MP3 Studio	Generate high-quality `yt-dlp` commands for audio extraction from videos and playlists, with cookie support for private content
Cookies.txt Converter	Convert browser cookie exports into `yt-dlp`-compatible Netscape format

Standout Tools: Deeper Dives

Video Studio is the most technically ambitious tool. It runs a full ffmpeg.wasm^[2] instance in a Web Worker, keeping the UI thread unblocked during heavy transcoding. Supported operations include trimming, reversing playback, resizing, cropping, rotating, color grading, and re-encoding. Outputs include video (MP4/WebM), animated GIF, individual PNG frames, and audio-only extractions — all processed on-device, never uploaded.

Flipper GUI Studio is a visual drag-and-drop canvas editor that generates valid C source code for Flipper Zero^[3] UI screens (compatible with the Momentum firmware). You build your layout visually, then export the auto-generated C file directly into your Flipper app project. It bridges the gap between wanting a polished UI and not wanting to write Flipper’s display API calls by hand.

OG Image Studio is the one tool that makes a server round-trip: it POSTs your title, subtitle, and theme choice to /api/og — a Vercel edge function — which renders a sharp 1200×630 card server-side and returns the PNG. The edge function approach delivers consistent font rendering without shipping a full font stack to the browser.

Metadata Studio handles five metadata formats in one place: EXIF (images), ID3 (audio), PDF metadata, Office document properties, and ZIP archive manifests. You can inspect all fields, edit what you want, and strip the rest — useful for privacy-cleaning files before sharing.

Technical Architecture

The project is 65.7% JavaScript, 27.5% HTML, and 6.8% CSS — deliberately vanilla, with no framework build step required. This keeps the contributor barrier minimal and the bundle size controlled.

Client-side tools run 100% in the browser using:

WebAssembly — ffmpeg.wasm for the Video Studio; compiled C/C++ running at near-native speed inside the browser sandbox.
Web Workers — heavy operations (video encoding, hash generation) run off the main thread.
FileReader / File System Access API — local file I/O without upload; files never leave the device.
Canvas API — used by the QR generator and Flipper GUI Studio for visual rendering.

Server-side tools use Vercel serverless functions exposed at https://api.tools.ranzlappen.com:

/api/og — OG Image Studio server-side card rendering.

The design-system CSS uses custom properties (tokens) for theming; a shared JS partial handles the dark/light theme toggle and backdrop effect consistently across all tool pages.

Deployment & Infrastructure

The site runs on two platforms:

Layer	Platform	URL
Static site + tools	GitHub Pages	`https://tools.ranzlappen.com` (custom domain)
API / serverless functions	Vercel	`https://api.tools.ranzlappen.com`
Fallback	GitHub Pages	`https://ranzlappen.github.io/tools/`

The GitHub Actions pipeline includes:

pages-deploy.yml — deploys the static site on every push to main
security-scan.yml — CodeQL, Gitleaks, and OpenSSF Scorecard^[4]
dependency-review.yml — per-PR CVE gating

No build step is required; the repo serves files directly, which means the pages-deploy workflow is a simple push to the gh-pages branch.

Privacy & Security

Privacy is a design constraint, not an afterthought:

No analytics — no Google Analytics, no tracking pixels, nothing that phones home on every visit.
Client-side processing — all file operations happen in the browser. The Video Studio, Metadata Studio, Color Picker, JSON Formatter, and most other tools never send your data to a server.
OG Image Studio exception — this tool sends your card text to the Vercel edge function. No data is stored; the function renders and returns the image immediately.
Service worker — basic offline support for previously visited tool pages.
MIT licensed — the full source is auditable at github.com/Ranzlappen/tools.

Standards Compliance

The project adheres to repo-standards v3 at full compliance, which means it ships with:

CHANGELOG.md, CONTRIBUTING.md, SECURITY.md, CODE_OF_CONDUCT.md
SHA-pinned workflow actions with least-privilege permissions
Automated security scanning (CodeQL, Gitleaks, OpenSSF Scorecard)
Dependency review on every PR

This makes it a useful reference implementation alongside the standards toolkit itself.

Key Takeaways

15 browser-based utilities spanning developer essentials (JSON, JWT, regex, UUID) through to specialized tools (Video Studio, Flipper GUI Studio, MIUI Theme Studio).
Strong emphasis on client-side execution — most tools process everything locally via vanilla JS and WebAssembly.
The Video Studio (ffmpeg.wasm) and Flipper GUI Studio (C code export) are standout tools with no easy browser-native equivalents.
No build step required: vanilla HTML/CSS/JS, deployable as static files.
Full repo-standards v3 compliance: security scanning, SHA-pinned CI, dependency review.

Conclusion

tools.ranzlappen.com offers a refreshing take on online utilities: fast, private, and genuinely useful without unnecessary complexity or data collection. Whether you need quick JSON formatting, video trimming, custom Flipper Zero interfaces, or social media graphics, there is likely a focused tool here that gets the job done efficiently.

It is especially valuable for developers and tinkerers who want capable tools without leaving the browser or compromising on privacy.

Visit the site — or browse the source repository.

More Project Showcases

Other projects in this series that might interest you:

Flipper Zero companion tools — Scripting and automation for the Flipper Zero (pairs with Flipper GUI Studio)
Pageside — Manifest V3 browser extension for CSS injection and media downloads
repo-standards — The versioned toolkit this project itself follows

Sources

Ranzlappen/tools — GitHub repository: source, README, CI configuration, and deployment setup (accessed June 2026).
ffmpeg.wasm — WebAssembly port of FFmpeg, powering the in-browser Video Studio tool.
Flipper Zero — The portable multi-tool for security researchers and hardware hackers; the Flipper GUI Studio exports C code for Flipper / Momentum firmware apps.
OpenSSF Scorecard — Automated supply-chain risk scoring tool integrated in the security-scan workflow.
Vercel Functions documentation — Serverless edge functions used by the OG Image Studio /api/og endpoint.

Synth Piano: A Powerful Android Synthesizer App (Despite the Misleading Repo Name)

2026-06-04T00:00:00+00:00

Introduction: It's an APK, Not a Web App

The repository is named Synth-piano-web, but don’t let the name fool you — this is a native Android application that produces APK and AAB artifacts. There is zero web technology involved. It is a full Kotlin + Jetpack Compose port of the original Python tkinter synthesizer,^[2] now running with a high-performance C++17 audio engine on Android.

Synth Piano brings professional-grade synthesis, MIDI editing, and low-latency performance to Android devices in a clean, touch-first interface. The source lives at Ranzlappen/Synth-piano-web^[1] and is licensed MIT.

What is Synth Piano?

Synth Piano is a touch-optimized software synthesizer and MIDI workstation for Android. It combines real-time audio synthesis, a playable touch keyboard, chord pads, a full piano-roll MIDI editor, USB-MIDI input, and high-quality recording — all in one cohesive app.

Originally written in Python with tkinter, it has been completely rebuilt for Android using modern native tools while preserving (and significantly extending) the original workflow and sound. The rewrite also fixes the latency constraints that affect any Python-based audio application.

Key Features

Multi-touch Keyboard — Play with up to 16 voices of polyphony. Configurable octave span and transposition.
Four Oscillator Shapes — Sine, square, sawtooth, and triangle with full ADSR envelope control per voice.
Chord Pads — 11 assignable pads supporting major, minor, 7^th, diminished, and suspended chord qualities across all 12 root notes.
Piano-Roll MIDI Editor — Full-featured editor: tap to add, drag to move/resize, long-press to delete. Multi-channel scores with per-note velocity and color coding. Includes four bundled demo MIDI files (Ode to Joy, Twinkle Twinkle, Frère Jacques, Scarborough Fair).
Standard MIDI File Support — Open and save .mid files (Format 0 & 1) using the Android Storage Access Framework. SMF Format 0 is flattened on read for editor compatibility.
USB MIDI Input — Connect class-compliant MIDI controllers via OTG with no additional permissions required.
Hardware Keyboard Support — Bluetooth and USB QWERTY keyboards work out of the box, fully remappable.
Sustain Pedal + Dynamics — Full sustain pedal support and dynamics engine in the synthesizer, recorder, and score editor (added in v0.1.33).
High-Quality Recording — Simultaneously records the master mix as WAV and a perfectly timed MIDI file with microsecond precision. Files are exported to the Downloads folder via MediaStore (Android 10+).

Technical Architecture

The app is organized into three clean layers:

Layer	Technology	Rationale
UI	Jetpack Compose^[3] + Material 3	Declarative layout suits the resizable keyboard; dynamic theming built in
Audio I/O	Oboe 1.9^[4] + AAudio	Google-endorsed path to <20 ms latency on modern devices
DSP Engine	C++17 (`app/src/main/cpp/`)	No GC pauses; lock-free audio callback
MIDI	`android.media.midi`^[5] + ktmidi	First-party USB MIDI + robust SMF parsing/generation
Persistence	AndroidX DataStore^[6]	Modern replacement for SharedPreferences; settings and key maps
Build	Gradle 8.10.2, AGP 8.5, CMake 3.22.1, Kotlin 2.0	Standard Android toolchain

The language distribution in the repository is approximately 88.9% Kotlin, 11.0% C++17, and 0.1% CMake.

The app is landscape-locked and responds correctly on phones, tablets, and foldables. Material 3 dynamic theming is fully supported.

The Audio Engine: C++ + Oboe

Real-time audio synthesis is the technical centerpiece of Synth Piano. The design is strict about the audio thread:

“The audio thread is sacred — no allocations, JNI callbacks, or locks in the Oboe callback.”

State changes flow from Kotlin to the native engine via std::atomic and a lock-free SPSC (single-producer, single-consumer) ring buffer for note events. This eliminates the two most common causes of audio glitches on Android: garbage collection pauses leaking into the callback, and lock contention between the UI thread and the audio thread.^[4]

The JNI bridge is NativeSynth.kt. The oscillator and envelope implementations live under app/src/main/cpp/. Oboe 1.9 selects AAudio automatically on Android 8.1+ (where it is stable), falling back to OpenSL ES on older devices.

The sub-20 ms latency target depends on the device’s audio HAL and hardware capabilities. A real device is recommended for latency validation; emulators add variable jitter that makes benchmarking unreliable.

MIDI Support in Depth

Synth Piano uses two MIDI paths in parallel:

USB MIDI input — android.media.midi handles class-compliant controllers connected via OTG. No special permissions are required; the API gained stable support in Android 6.0 (SDK 23) and is reliable on Android 10+ (SDK 29, the app’s minimum).
SMF read/write — the ktmidi library handles Standard MIDI File parsing and generation. Both SMF Format 0 (single-track) and Format 1 (multi-track) are supported on read; Format 0 files are flattened to a single channel list for the piano-roll editor.

The piano-roll editor preserves per-note velocity, supports multi-channel color coding, and allows notes to be dragged, resized, or deleted with natural touch gestures. The MIDI recorder captures events with microsecond timestamps from the audio thread’s monotonic clock, ensuring the saved .mid file is perfectly synchronized with the WAV recording.

Building & Installing

Prerequisites:

JDK 17 (Temurin recommended)
Android SDK platform 35, build-tools 35.0.0
NDK r27
CMake 3.22.1

Quick commands:

./gradlew assembleDebug          # Debug APK (unsigned)
./gradlew bundleRelease          # Release AAB (requires signing config)
./gradlew test                   # JVM unit tests
./gradlew connectedAndroidTest   # Device or emulator tests

For a signed release AAB, configure the four secrets in your local.properties or CI environment: KEYSTORE_BASE64, KEYSTORE_PASSWORD, KEY_ALIAS, KEY_PASSWORD.

Or simply download a pre-built signed APK from the releases page — no build environment needed.

Releases & CI/CD

GitHub Actions runs .github/workflows/ci-android.yml on every push to main, on pull requests, and on tags matching v*. The pipeline:

Builds a release-signed AAB automatically on every merge
Bumps the patch version automatically (v0.1.x → v0.1.x+1) for routine merges
Creates a GitHub Release with the APK attached
Supports tag-based releases for explicit version names
Add [skip release] to a commit message to suppress the auto-release

As of June 2026, the latest release is v0.1.33, which added full sustain pedal and dynamics support across the engine, recorder, and score editor. The project has been actively released with multiple updates per sprint.

Pitfalls & Device Notes

Latency varies by device — the sub-20 ms target is achievable on flagship devices with low-latency audio HALs (Pixel, recent Samsung, etc.). Budget devices may have higher latency regardless of the engine quality. Use the Android audio latency checker to benchmark your hardware.
OTG cable required for USB MIDI — a standard USB-C cable without OTG support will not enumerate MIDI devices. Use an OTG-capable adapter or hub.
SMF Format 1 read-flattening — multi-track Format 1 files are merged into a single channel list on import. The original per-track structure is not preserved in the editor’s internal model; if you need per-track isolation, export as Format 1 before importing.
Emulator audio jitter — emulators introduce variable scheduling delays that defeat latency benchmarking. Test audio-critical paths on a real device.
NDK r27 required — older NDK versions have known C++17 atomics issues on certain ABIs. Stick to NDK r27 for the CMake build.

Key Takeaways

Synth Piano is a native Android APK app built with Kotlin 2.0 + Jetpack Compose — the repository name Synth-piano-web is simply a legacy artifact.
The C++17 audio engine via Oboe 1.9 targets <20 ms latency with a lock-free audio callback — a genuine real-time design, not an approximation.
Full MIDI workstation features: USB-MIDI input, piano-roll editor, SMF 0 & 1 support, synchronized WAV + MIDI recording.
16-voice polyphony, four oscillator shapes, full ADSR envelopes, and sustain pedal support.
MIT licensed; auto-released APKs on GitHub Releases — latest is v0.1.33 as of June 2026.

Conclusion

Synth Piano proves that you can build a serious, low-latency music creation tool entirely on Android using modern native technologies. Despite the confusing repository name, this is a polished, feature-rich APK that Android musicians and tinkerers will genuinely enjoy. Whether you want to play, compose, record ideas, or just experiment with synthesis on your phone or tablet, Synth Piano is a compelling proof of concept done right.

View the repository and grab the latest release APK directly — no Play Store account needed.

More Project Showcases

Other projects in this series that might interest you:

HardwareDash — Modular Android dashboard for sensors, radios, and hardware automation
Ticked — A lightweight habit-tracker PWA
MoodRadar — Twitch chat sentiment analysis

Sources

Ranzlappen/Synth-piano-web — GitHub repository: README, release history, and build configuration (accessed June 2026).
Ranzlappen/synth-piano — The original Python tkinter synthesizer that Synth Piano for Android ports and extends.
Jetpack Compose documentation — Android's modern declarative UI toolkit used for the keyboard, chord pads, and piano-roll editor.
google/oboe — Google's C++ library for low-latency Android audio; wraps AAudio (Android 8.1+) with an OpenSL ES fallback. Version 1.9 used in Synth Piano.
Android Developers — android.media.midi — The native MIDI API used for USB-MIDI controller input via OTG.
AndroidX DataStore — Persistence library used for settings and hardware key mappings.
atsushieno/ktmidi — Kotlin MIDI library providing robust SMF (Standard MIDI File) Format 0 and 1 parsing and generation.

repo-standards: A Toolkit for Consistent, High-Quality GitHub Repositories

2026-06-04T00:00:00+00:00

Introduction

Maintaining multiple GitHub repositories at a high standard can quickly become repetitive and error-prone. repo-standards solves this by providing a living, versioned toolkit that defines what “good” looks like — and gives you the tools (including AI prompts) to bring existing repositories up to that standard efficiently.

It is the distilled result of years of refinement across the author’s own projects and is actively dogfooded in the standards repository itself. The project lives at Ranzlappen/repo-standards^[1] and is currently at v3.2.0.

What is repo-standards?

repo-standards is a portable framework that helps developers and maintainers bring consistency, security, and professionalism to their GitHub repositories. It answers two practical questions:

What does a well-maintained repository look like?
How can I bring my existing repos up to that level with minimal manual effort?

The answer is a combination of:

Clear templates and folder structures
Security and supply-chain hardening practices
Documentation and governance standards
Automated upgrade processes powered by Claude Code^[2]
Versioned releases so you can track compatibility via a .standards-version file

Version History: v1 → v3

The standards follow semantic versioning. A repository’s .standards-version file declares which major version it follows; the upgrade tooling refuses to apply v2 rules to a v1 repo (or vice versa), preventing silent conflicts.

Version	Major additions
v1	Basic repository structure and community files
v2	“Tiny-commit rhythm” (one file per response), Conventional Commits enforcement, hardened CI with least-privilege permissions and SHA-pinned workflow actions
v2.1	Refactoring-guide documentation, OIDC-based automated publishing (npm, PyPI, GHCR), governance templates, AI-native `CLAUDE.md` support and multi-AI coordination playbooks
v3	Dogfoods its own standards; modular prompt structure; OpenSSF Scorecard^[3] integration; Phase 0 migration-planning layer; supply-chain baseline with dependency-review gates

The current release, v3.2.0, introduces the one-step upgrade instruction: copy PROMPT.md into a fresh Claude Code session.

Key Features

Versioned Standards (v3) — Semantic versioning so every repository knows exactly which standard it follows. The .standards-version file is the single source of truth.
AI-Assisted Upgrades — A modular PROMPT.md that Claude Code can execute to upgrade a repository through a structured sequence of pull requests.
Security & Supply Chain — Includes CodeQL, Gitleaks, dependency review, OpenSSF Scorecard, signed commits, and OIDC publishing with no stored tokens.
Strong Documentation Practices — Templates for README, CHANGELOG, CONTRIBUTING, SECURITY, GOVERNANCE, and Architecture Decision Records (ADRs).
Code Quality Tooling — Pre-configured linting, formatting, and pre-commit hooks for Node (ESLint, Prettier), Python (Ruff, pyproject.toml), and Android projects.
AI-Native Support — Includes CLAUDE.md templates, .cursorrules, and an AI Team Playbook for working effectively with multiple AI coding assistants.
Dogfooding — The standards repository itself follows every rule it defines, verified by dogfood-audit.py on every PR.

How It Works

There are two execution flows:

Option A: GitHub Actions (recommended for mobile or shared machines)

Install the Claude Code GitHub Action in your target repository.
Open an issue titled “Upgrade to repo standards”, paste the contents of PROMPT.md in the body, and tag @claude.
Claude posts a Phase 0 plan, waits for your confirmation, then opens the canonical sequence of pull requests.
Review and merge each PR; CI runs automatically after each merge.

Option B: Direct Claude Code session

Clone the target repository locally (or open it in the Claude Code Android app).
Start a new session and paste PROMPT.md as the first message.
Claude profiles the repo (Phase 0), scores each checklist item by effort × value × risk, and presents a tailored roadmap before touching a single file.
You confirm; Claude works through the 8-PR canonical sequence.

Both flows are auditable, reversible where possible, and designed to respect existing behavior 100%. Claude is instructed to stop and propose options rather than self-decide on any conflict.

The Modular Prompt System

PROMPT.md is an entry-point index that references seven focused files under prompt/:

File	Purpose
`migration-planning.md`	Phase 0 — repo profile, scoring, and roadmap
`00-version-check.md`	Compatibility gate (refuses major-version mismatches)
`01-ground-rules.md`	The 18 non-negotiable behavioral rules in full
`02-canonical-pr-sequence.md`	Steps 1–2: read, audit, plan the 8-PR sequence
`03-pr-description.md`	Step 3: required PR structure
`04-wiki-seeding.md`	Step 4: optional Wiki integration
`05-migration-debrief.md`	Step 5: mandatory session debrief

The 18 ground rules include: behavior preservation (100% of original functionality must survive), the tiny-commit discipline (one file per response, one Conventional Commit per change), post-task self-checks after every commit, and a branch-guard rule (rebase, never merge, when behind origin/main).

Security & Supply-Chain Hardening

Supply-chain security is a first-class concern in v3:^[4]

SHA-pinned workflow actions — all uses: lines in provided workflow templates are pinned to 40-character commit SHAs with a trailing # vX.Y.Z comment. Dependabot bumps both the SHA and the comment so pins stay current without manual effort.
Least-privilege permissions — every workflow job declares the minimum permissions: it needs; nothing defaults to write-all.
Gitleaks scanning — runs on every PR and on a weekly schedule to catch accidentally committed secrets.
CodeQL analysis — static security scanning for supported languages.
OpenSSF Scorecard — weekly runs with badge integration, surfacing supply-chain risk scores publicly.^[3]
Dependency review — a required PR status check that gates on CVE severity “high” using the GitHub dependency-review-action.
OIDC publishing — release-please.yml publishes to npm, PyPI, and GHCR via OIDC (no long-lived token stored as a secret).
Pre-commit hook — blocks files ≥ 5 MB before push to prevent accidental large-binary commits.

Templates & Tooling Configs

The templates/ directory contains ready-to-use boilerplate for downstream consumers:

Community files: CODE_OF_CONDUCT.md, CONTRIBUTING.md, SECURITY.md, FUNDING.yml, CODEOWNERS

Workflow templates:

dependency-review.yml — per-PR CVE gating
security-scan.yml — CodeQL + Gitleaks + OpenSSF Scorecard
release-please.yml — OIDC-based publishing (npm / PyPI / GHCR), disabled by default, activated per repo via repository variables
stale.yml — opt-in issue/PR housekeeping
dogfood-audit.yml — self-compliance verification

Language-specific CI: templates for Node, Python, static HTML, and Android projects.

Tooling configs: .editorconfig, Prettier, ESLint flat config, Ruff, pyproject.toml, Vitest, pre-commit hooks.

AI support files: CLAUDE.md template, .cursorrules, and an AI Team Playbook for multi-assistant coordination.

GitHub Wiki layouts: Home, Architecture, FAQ, and Migration Guide page templates.

Self-Validation & Dogfooding

dogfood-audit.py runs 8 assertion groups covering 33 invariants on every pull request:

LICENSE compliance
Versioning correctness (.standards-version present and valid)
Community files presence
Workflow integrity (SHA pins, permissions declarations)
README badge validity
Modular prompt structure
Placeholder hygiene (no unreplaced TODO placeholders in shipped files)
Workflow–sidecar pairing (each workflow has a corresponding test or check)

Every PR must pass all 33 invariants before merge. The standards repository cannot publish a version it cannot itself satisfy — that is the dogfooding guarantee.

Pitfalls & Ground Rules

A few things worth knowing before you run the upgrade prompt:

Major-version compatibility — the tooling hard-refuses to apply v3 rules to a v1 or v2 repo. Run a version bump PR first if needed.
Android repos last — the recommended upgrade order is: single-file HTML → small utilities → larger projects → Android (the toolchain is different enough to warrant separate care).
Out-of-scope issues — if Claude discovers problems beyond the upgrade scope, it auto-files GitHub issues rather than fixing them silently. Set DISABLE_OUT_OF_SCOPE_ISSUES=true to suppress.
Token budget — sessions are sized at ~30% context per response and ~4-hour caps. Large repos may need multiple sessions to complete the full 8-PR sequence.
Behavior preservation is non-negotiable — the prompt explicitly forbids changing any user-facing behavior or API contract. Standards are additive.

Key Takeaways

repo-standards provides a clear, versioned definition of what a high-quality GitHub repository looks like, currently at v3.2.0.
The modular PROMPT.md + Claude Code integration dramatically reduces the effort required to standardize repositories — from days of manual work to a guided sequence of reviewed PRs.
Strong emphasis on supply-chain security: SHA-pinned actions, OIDC publishing, OpenSSF Scorecard, Gitleaks, and a pre-commit size gate.
Excellent documentation and template coverage across Node, Python, static HTML, and Android stacks.
Actively maintained and dogfooded: the standards repo must itself pass dogfood-audit.py on every commit.

Conclusion

For anyone maintaining more than one or two repositories, repo-standards offers a practical and thoughtful way to raise quality, improve security, and reduce long-term maintenance burden. The combination of clear standards, high-quality templates, and AI-assisted migration — backed by a self-validating dogfood loop — makes it especially compelling in 2026.

Whether you want to bring existing projects up to a professional standard or start new ones on a solid foundation, this toolkit is worth a look.

View the repository — MIT licensed, v3.2.0 current.

More Project Showcases

Other projects in this series that might interest you:

Pageside — Manifest V3 browser extension for CSS injection, TTS, and media downloads
tools.ranzlappen.com — Browser-based developer utilities
Discord Music Bot — A self-hosted Discord music bot

Sources

Ranzlappen/repo-standards — GitHub repository: README, PROMPT.md, UPGRADE_CHECKLIST.md, templates/, and v3.2.0 release (accessed June 2026).
Claude Code — Overview — Anthropic's official documentation for Claude Code, the AI coding assistant used to execute the upgrade prompt.
OpenSSF Scorecard — Automated supply-chain risk scoring tool integrated in the v3 security-scan workflow.
GitHub Docs — Security hardening for GitHub Actions — The official guidance on least-privilege permissions and SHA-pinned actions that underpins the v3 supply-chain hardening.
Conventional Commits v1.0.0 — The commit-message specification enforced by the v2+ "tiny-commit rhythm" ground rule.
Release Please — The automated release PR tool used in the OIDC publishing workflow template.

Pageside: A Lightweight Browser Extension for Custom Styling, Inspection, TTS & Media Downloads

2026-06-04T00:00:00+00:00

Introduction

Pageside is a lightweight, privacy-respecting browser extension that gives you practical tools to customize websites, inspect elements, listen to text, and save media — all running entirely in your browser with no servers, accounts, or telemetry.

The repository is named web_extension on GitHub,^[1] but the extension itself ships under the name Pageside. It is a fully functional Manifest V3^[2] extension focused on real daily-use features rather than flashy marketing — and it requires no build step to develop or install. The current release is v2.0.5.^[6]

The whole UI is a stack of collapsible sections — Style, Notes, Password, Tools, and Tabs — tuned for both a desktop popup and a phone-sized panel (large tap targets, safe-area padding, no horizontal overflow).

Key Features

Per-Domain CSS Injection — Write and save custom CSS snippets that apply automatically on every subsequent visit to a specific domain. Perfect for removing annoying banners, adjusting font sizes, or permanently tweaking a site’s layout.
Element Inspector — Click Select Container, then hover (or drag on touch) over any element to copy its CSS selector to the clipboard, without opening DevTools. Ideal for debugging styles or targeting elements for your custom CSS rules.
Text-to-Speech (TTS) — Select any text and have it read aloud using the browser’s built-in Web Speech API.^[3] Supports multiple languages and accents depending on the voices installed in your OS.
Video & Media Downloader — Right-click any video element or use the popup to detect and extract video source URLs. The scanner walks video.currentSrc, <source> tags, media-typed <a href> links, network resource entries, and (on YouTube) ytInitialPlayerResponse, then ranks the results and downloads through chrome.downloads.
Per-Domain Notes — A private, free-form notepad bound to the current site’s base domain. It auto-saves as you type and reloads the right note when you switch domains — handy for jotting credentials hints, to-dos, or context for a site.
Password & Passphrase Generator — Build strong secrets with the browser’s cryptographic RNG (crypto.getRandomValues, never Math.random). Length slider, character-set toggles (including accented, Cyrillic, Greek, and CJK letters), “exclude ambiguous”, “require each selected set”, a hyphenated-word passphrase mode, and a live entropy meter. Nothing generated is ever stored.
Tab Organizer — Sort every open tab across all windows by domain, title, or URL; group same-domain tabs into native tab groups (Chrome/Edge desktop); close duplicate tabs; and filter the live list to jump to any tab.
Local-First Storage — All CSS snippets and preferences are saved in chrome.storage.local.^[4] Export and import your full configuration as JSON at any time (private notes are deliberately excluded from exports).
Context Menu Integration — Right-click context menus for one-click video downloads, powered by the background service worker.
Cross-Browser UI — Popup interface on Chromium-based browsers; sidebar mode on Firefox and Opera.

Everything runs client-side. No data ever leaves your browser.

The Style section — write and save per-domain CSS, or pick an element with Select Container.

Not sure what to type into that box? Here are some of the most common one-liners. Use Select Container to grab the exact .class or #id you want to target, then drop it into one of these patterns (add !important if the site’s own styles win):

Goal	Snippet
Hide an element (banner, popup, sidebar)	`.cookie-banner { display: none; }`
Hide by id	`#newsletter-modal { display: none; }`
Hide everything an element contains but keep its space	`.ad-slot { visibility: hidden; }`
Bump the base font size for readability	`body { font-size: 18px; }`
Widen a cramped reading column	`.article { max-width: 100%; }`
Re-enable scrolling a modal locked	`html, body { overflow: auto !important; }`
Un-stick a sticky/fixed header	`.site-header { position: static !important; }`
Force a calmer background + text colour	`body { background: #0f121c; color: #e6e8ef; }`
Recolour all links	`a { color: #4aa3ff; }`
Hide images (data-saver / declutter)	`img { display: none; }`
Kill an overlay dimmer	`.overlay, .backdrop { display: none !important; }`
Apply to the whole page	`* { animation: none !important; }`

The Password section — a local crypto generator with character-set toggles, a passphrase mode, and a live entropy meter.

The Tabs section — sort, group by domain, de-duplicate, and jump across every open tab.

The Tools section — TTS Read Aloud, the video-media downloader, and saved-snippet backup/export.

The Notes section — a private, per-domain notepad that auto-saves and stays local.

How It Works

Pageside’s four key files map cleanly to four jobs:

File	Role
`manifest.json`	Declares MV3 configuration: permissions, content scripts, service worker, action popup, and sidebar panel
`content.js`	Injected into every page at `document_start`; handles CSS injection and the element-inspector overlay
`background.js`	Service worker; registers context menus and relays download requests
`popup.html` / `popup.js`	The main UI orchestrator: CSS editor, element picker, TTS controls, media scanner, and saved-snippet list
`popup-notepad.js`	The per-domain Notes module (auto-save, backed by the reserved `__ps_notes` storage key)
`popup-password.js`	The cryptographic password / passphrase generator (stores nothing)
`popup-tabs.js`	The Tabs organizer — sort, group-by-domain, de-duplicate, and list tabs across windows

When you type CSS into the popup editor and click Save, the snippet is stored under the current domain key in chrome.storage.local. The content script’s storage.onChanged listener picks up the change and immediately applies the new styles via a dynamically injected <style> element — no page reload required.

The element inspector activates a hover overlay in content.js that highlights elements and computes the shortest unique CSS selector as you move your cursor. Clicking copies the selector and dismisses the overlay.

TTS passes the selected text to window.speechSynthesis.speak() in the popup context, using the browser’s native voices — no audio data ever transits a server.^[3]

The media downloader scans each frame for video.currentSrc, <source> tags, media-typed <a href> links, and network resource entries, then surfaces those URLs in the popup list ranked by how likely each is to be a real downloadable file. The YouTube path uses a separate extraction strategy (ytInitialPlayerResponse) due to the platform’s multi-quality stream URLs. Blob streams are shown disabled — they cannot be fetched directly.

Architecture Deep-Dive

Manifest V3 constraints shape the design deliberately. MV3 replaces persistent background pages with an event-driven service worker,^[2] which means Pageside’s background.js wakes up only on context-menu clicks and goes dormant otherwise — a deliberate memory-saving trade-off.

Storage uses chrome.storage.local rather than localStorage because storage is accessible from both the content script and the popup via the same async API, without message passing. The data model is a flat key-value map where the key is the page’s base domain — the last two labels of the hostname, so www.foo.example.com resolves to example.com — and the value is the saved CSS string. Non-CSS state (the per-domain notepad, fallback host detection) is namespaced under a reserved __ps_ prefix so it can never collide with a bare-domain CSS key, and those keys are excluded from the JSON export.

Content script injection is declared in manifest.json to run at document_start so saved styles land before the page paints (no flash of unstyled content). The script is kept side-effect-free until a saved snippet is found, then injects them into a dedicated <style> element with a deliberately neutral, randomized id so they can be cleanly removed or updated without touching the page’s own styles — and so anti-extension detection scripts can’t fingerprint Pageside by a predictable marker.

No build step is intentional and a feature: the extension loads as raw HTML/CSS/JS from the domain-css-injector-v2/ folder. This keeps the barrier to contribution as low as possible and avoids introducing a bundler dependency for what is fundamentally a small codebase.

Browser & Platform Support

Browser	Minimum Version	Notes
Chrome	116+	Primary target; popup UI
Edge	116+	Same as Chrome
Opera	102+	Sidebar mode available
Firefox	121+	Sidebar mode; uses `browser.*` API shim
Kiwi Browser (Android)	Any extension-capable build	Install via `.zip` package
Yandex Browser (Android)	Extension-capable build	Same as Kiwi
Mises Browser (Android)	Extension-capable build	Same as Kiwi
Firefox Nightly (Android)	geckoview-based	Via Firefox Android Add-ons

The extension targets Chromium 116+ because that is when MV3 reached full stability for offscreen documents and context-menu APIs used by the downloader.^[2]

Getting Started

Download: every tagged release on the Releases page attaches two packaged zips:^[6]

pageside-2.0.5.zip — the Manifest V3 build for desktop Chrome / Edge / Opera / Firefox.
pageside-2.0.5-kiwi.zip — the Manifest V2 build for Kiwi and other Android Chromium forks (their experimental MV3 support silently rejects the standard zip). Both contain the same features — only the manifest differs.

Or just clone the repo and load the folder unpacked — no build step either way.

Desktop (Chrome / Edge / Opera):

Download pageside-2.0.5.zip (above) and unzip it, or clone the repo: git clone https://github.com/Ranzlappen/web_extension
Open chrome://extensions (or edge://extensions / opera://extensions).
Enable Developer mode (top-right toggle).
Click Load unpacked and select the unzipped folder (or the domain-css-injector-v2/ folder from a clone).
Pin the Pageside icon to your toolbar.

Firefox:

Open about:debugging#/runtime/this-firefox.
Click Load Temporary Add-on and select manifest.json inside domain-css-injector-v2/.
For permanent installation, pack the directory as a .zip and submit to addons.mozilla.org.

Android (Kiwi Browser recommended):

Download pageside-2.0.5-kiwi.zip (the Manifest V2 build) to your phone. Kiwi silently fails to load the MV3 zip, so the -kiwi.zip is the one to use.
In Kiwi, open kiwi://extensions, enable Developer mode (top-right), tap + (from .zip/.crx/.user.js), and pick the downloaded zip.
The popup appears under the ⋮ menu (and can be pinned to the toolbar).

Full installation details are in the repository README.

Privacy & Security

Pageside was designed privacy-first from the ground up:

No remote endpoints — the extension makes zero outbound network requests of its own.
No analytics or crash reporting — nothing phones home.
chrome.storage.local only — your CSS snippets are stored locally, not synced to chrome.storage.sync (which would send them to Google’s servers).
No account required — there is no sign-in, no cloud backend, nothing to breach.
Scoped permissions — every permission maps to a visible feature: storage (saved snippets/notes), activeTab + scripting (touch a tab only when you open the popup), tabs + tabGroups (the Tabs organizer; tabGroups is Chrome/Edge-desktop only and is stripped from the mobile build), clipboardWrite (copy selectors/passwords), downloads (save video media), and contextMenus (the right-click “Download this video” entry).
Open source (MIT) — you can audit every line of code before installing.

The only data that leaves the browser is what you explicitly send when you use the video downloader to copy a URL and then fetch it in a download manager.

Pitfalls & Known Limits

HTTPS only on Android — on Kiwi and similar Android browsers, content scripts only inject reliably on HTTPS pages.
YouTube downloads — the media extractor can surface stream URLs but YouTube’s signed-URL scheme means those links expire quickly. Use a dedicated tool (e.g. yt-dlp) for reliable YT downloads.
Service worker lifetime (MV3) — the background service worker can be terminated by the browser when idle. Context menus persist across worker restarts, but any in-memory state does not (by design, there is none).
CSP-protected pages — sites with a strict Content-Security-Policy may block the injected <style> element. The extension cannot override a server-set CSP header.
Firefox temporary install — loading as a temporary add-on in Firefox means it disappears on browser restart. For persistence, sign and submit via AMO.

Key Takeaways

Pageside is a practical, no-nonsense Manifest V3 browser extension focused on daily web customization and media access.
It bundles five tools behind one popup/sidebar: per-domain CSS styling, one-click element inspection, built-in TTS via the Web Speech API, a video-media downloader, a per-domain notepad, a cryptographic password/passphrase generator, and a cross-window tab organizer — all locally.
The extension is lightweight, privacy-first, and works across Chrome 116+, Edge 116+, Opera 102+, Firefox 121+, and Android via Kiwi Browser (a dedicated Manifest V2 build).
Download the prebuilt zip from Releases (currently v2.0.5), or clone and load unpacked — zero build tooling required either way.
Licensed MIT; the entire codebase is auditable before installation.

Conclusion

Pageside proves that useful browser extensions don’t need to be complicated or privacy-invasive. With its combination of custom styling, inspection tools, accessibility features (TTS), and media downloading, it offers genuine everyday value while staying completely local and lightweight.

If you frequently customize websites, debug layouts, want quick TTS on articles, or need an easy way to surface video URLs, Pageside is worth adding to your toolkit.

View the repository on GitHub — MIT licensed, no build step needed.

More Project Showcases

Other projects in this series that might interest you:

tools.ranzlappen.com — Browser-based developer utilities (JSON, video editing, Flipper GUI, and more)
repo-standards — Versioned toolkit for high-quality GitHub repositories
MoodRadar — Twitch chat sentiment analysis

Sources

Ranzlappen/web_extension — GitHub repository: README, source files, and manifest (accessed June 2026).
Chrome Developers — What is Manifest V3? — Overview of MV3 architecture changes including service workers, chrome.scripting, and the removal of persistent background pages.
MDN — Web Speech API — The browser-native speech synthesis interface used by Pageside's TTS feature.
Chrome Developers — chrome.storage API — Reference for chrome.storage.local used to persist CSS snippets and settings.
Chrome Developers — chrome.contextMenus API — Context menu API used by the background service worker to register the right-click video download action.
Ranzlappen/web_extension — Releases — Tagged releases attaching the desktop (MV3) and Kiwi/Android (MV2) zip builds; current version v2.0.5 (accessed June 2026).

HardwareDash (Gadget) on the Legacy Branch: A Proof-of-Concept for Exploring and Automating Android Hardware & Software

2026-06-04T00:00:00+00:00

Introduction

HardwareDash — shipped under the app name Gadget — is a modular Android application designed as a proof of concept for deeply exploring and automating the hardware and software layers of your device. Whether you want to monitor every sensor in real time, control radios and actuators, manage storage and apps, or build automation rules that react to hardware events, this app provides a unified, extensible interface.

The project lives in the Ranzlappen/HardwareDash repository.^[1] Active development happens on the claude/refactor-2026 branch, where a major modular refactor has progressed through Phases 0 and 1 and is currently mid-Phase 2.

Try the latest build: R8-minified release APKs for both flavors — standard and rooted — are published automatically on every merge to main. The releases page had reached v1.0.173 by June 2026, with multiple builds per day during active sprints. Both variants install side-by-side as separate apps.

The Vision: Proof of Concept for Exploration & Automation

At its core, HardwareDash aims to give power users, developers, and tinkerers a single place to inspect, control, and automate almost every hardware surface Android exposes — and deeper system surfaces on rooted devices.

Instead of juggling dozens of separate tools, you get one coherent dashboard with sensor tiles, actuator controls, radio management, and a rule engine that lets you automate actions based on hardware state changes. It is deliberately built as a proof of concept to demonstrate what a truly integrated hardware-software automation platform on Android can look like.

The project targets Android 10 (SDK 29) and up through Android 15 (target SDK 35), compiled against SDK 35 and using Java/Kotlin 17 toolchains.^[1]

Core Capabilities at a Glance

Dashboard — Adaptive grid of live sensor and status tiles (battery, motion, ambient, GPS, etc.).
Sensors & Actuators — Direct access to sensors, torch/flashlight, vibration, cameras, and audio.
Radio Suite — Unified control panel for Wi-Fi, Bluetooth, NFC, sub-GHz, and IR radios.
Specialized Modules — Dedicated support for Flipper Zero devices, storage management, app control, screen lock behavior, and bug report generation.
Automation Engine — Rule-based automation in core/automation with a companion UI, allowing users to define reactions to hardware events.
Rooted Flavor Extras — Deeper diagnostics, storage, apps, lock, and bug-report surfaces available only in the rooted build, plus a bundled LSPosed module.

Everything is organized so users can explore hardware behavior interactively while also scripting automated workflows.

Modular Architecture & Dual Flavors

The app uses a clean modular monorepo structure with three top-level directories:

core/ — Reusable infrastructure with no user-facing UI:

Module	Role
`core:common`	Utilities and shared data models
`core:domain`	Use-case implementations
`core:data`	Repositories, Room, network calls
`core:datastore`	Settings persistence (AndroidX DataStore)
`core:ui`	Component library, Compose design system
`core:navigation`	Navigation, deep-link routing
`core:permissions`	Permission lifecycle manager
`core:hardware`	Hardware registries and HAL abstractions
`core:testing`	Shared test fixtures and Hilt test utilities

feature/ — Focused capability modules, one per user-facing screen or surface: dashboard, sensors, actuators, battery, audio, camera, WiFi, Bluetooth, NFC, sub-GHz, IR, storage, apps, lock, bug reports, and their rooted-only counterparts.

build-logic/ — Eight Gradle convention plugins (Android application, Android library, Compose, Hilt, Room, etc.) that eliminate boilerplate from every module’s build.gradle.kts.

Two product flavors are maintained from the same codebase:

standard (dev.ranzlappen.gadget) — Ships on the Play Store, works on any Android 10+ device without root.
rooted (dev.ranzlappen.gadget.rooted) — Side-loaded only; unlocks deeper system surfaces and includes the LSPosed module. Requires Magisk, KernelSU, or APatch.

Both install simultaneously as separate apps. New code lives exclusively under the dev.ranzlappen.gadget.** namespace; legacy com.gadget.** paths are never imported in active branches.

Building the Project

The standard debug APK needs no special flags:

./gradlew :app:assembleStandardDebug

The rooted build requires opting in explicitly:

./gradlew -PenableLsposedModule=true :app:assembleRootedDebug

For a release AAB (requires signing config):

./gradlew bundleRelease

Code quality checks (Detekt + ktlint):

./gradlew detekt ktlintCheck

Contributors working in Claude Code containers do not need a local Android SDK — CI validates build correctness. Development targets the claude/refactor-2026 branch; do not push to main until Phase 2 merges.

The Legacy/Refactor Branch (claude/refactor-2026)

The branch claude/refactor-2026 is the active development target. The original main branch contains the production-ready 1.x codebase (legacy), while the refactor branch is building the clean 2.0 foundation. The original monolithic codebase is archived in legacy-main as a read-only reference.

Key documentation on this branch:

MASTER-PLAN.md — The phased roadmap with acceptance criteria per phase.
AI-COLLABORATION.md — Documents AI-assisted development practices and token-budget guidelines.
docs/adr/0001-monorepo-refactor.md — The architectural decision record for the module split.
docs/migration-guide.md — The eight-step recipe used to migrate each feature from legacy to the new module structure.

Refactor Phase Status

Phase	Description	Status
Phase 0	Monorepo foundation: 8 convention plugins, 44 module skeletons, Kotlin DSL migration, new app IDs	✅ Complete
Phase 1	Light-preview skeleton: component library, core infrastructure, accessibility hardening, design system docs	✅ Complete
Phase 2	Feature migration: Settings v1, torch/flashlight, QS tiles, home widgets — following the eight-step migration recipe	🚧 In progress
Phase 3	Advanced capabilities: cross-automation engine, full widget coverage, permission UI, custom theming	⏳ Planned
Phase 4	Release readiness: instrumented tests, CI emulator workflows, performance benchmarks, Play Store preparation	⏳ Planned

Three tracked issues are deferred to Phase 4: adaptive foldable utilities (#89), BottomSheet testing infrastructure (#91), and the CI emulator workflow (#92).

Security & CI Gates

A strict automated gate in CI prevents rooted-only code from ever entering the standard APK. Every pull request runs both detekt (static analysis) and ktlintCheck (style enforcement) before merge. All commits to the repository carry GitHub’s cryptographic signature verification. The 99.8% Kotlin codebase keeps the attack surface narrow and the toolchain uniform.

Roadmap

Phase 2 is currently migrating the first wave of features (Settings, Torch, QS tiles). Once that batch merges, Phase 3 will bring the full cross-automation engine — connecting hardware events (e.g., battery below 20%, NFC tag read, GPS geofence crossed) to arbitrary actuator actions across the whole feature set. Phase 4 closes the loop with instrumented device tests and Play Store submission for the standard flavor.

Contributions on claude/refactor-2026 are welcome. Atomic commits (one logical change per commit, Conventional Commits format), a review pause between batches, and documentation of decisions in docs/adr/ are the norms.

Key Takeaways

HardwareDash is a true proof-of-concept that unifies hardware monitoring, control, and rule-based automation in one modular Android app.
It supports both everyday devices (standard flavor) and rooted devices with deeper system access (rooted flavor), installable side-by-side.
The multi-module monorepo (44 skeletons, 8 convention plugins) is already in place — Phase 2 is actively migrating features into it.
The automation engine and extensive hardware coverage (including advanced radios and Flipper Zero integration) make it uniquely powerful for exploration and scripting.
R8-minified, signed release APKs for both flavors are published automatically on every merge to main.

Conclusion

HardwareDash stands out as an ambitious, well-architected proof of concept that lets users truly explore and automate the hardware and software layers of their Android devices. Whether you are a developer debugging sensors, a tinkerer automating routines, or a power user wanting deeper control, this app offers a glimpse of what unified hardware automation on Android can look like.

The work on claude/refactor-2026 is laying a solid modular foundation — Phase 0 and Phase 1 are done, Phase 2 is actively landing. If you are interested in Android internals, automation, or rooted tooling, HardwareDash is worth watching and contributing to.

Star the repository and check out the claude/refactor-2026 branch to follow progress or grab the latest release APK.

More Project Showcases

Other projects in this series that might interest you:

Flipper Zero companion tools — Scripting and automation for the Flipper Zero
Synth Piano (Android APK) — Low-latency synthesizer and MIDI workstation
Ticked — A lightweight habit-tracker PWA

Sources

Ranzlappen/HardwareDash — GitHub repository: README, MASTER-PLAN.md, architecture ADRs, and build configuration (accessed June 2026).
HardwareDash Releases — Automated R8-minified APKs for standard and rooted flavors; v1.0.173 current as of June 2026.
Android NDK Guide — Concepts — Background on the Android hardware abstraction layers and native development used by the rooted flavor.
Guide to Android app modularization — The official architecture guidance that informs the core/ + feature/ module split.
AndroidX DataStore — The persistence library used in :core:datastore for settings and key mappings.

Flipper: A Beginner-Friendly Development Framework for Custom Flipper Zero Apps & Scripts

2026-06-04T00:00:00+00:00

Introduction

The repository named Flipper is not a Flipper Zero application or custom firmware. Instead, it is a thoughtfully designed development framework and starter kit that helps users quickly build their own applications and scripts for the Flipper Zero^[2] running Momentum Firmware^[3].

It lowers the barrier to entry by offering two development paths: easy JavaScript scripting (possible entirely from a phone, no computer required) and more powerful native C .fap applications for performance-critical use cases.

Repository: github.com/Ranzlappen/Flipper

What is the Flipper Repository?

This project provides templates, examples, documentation, and tooling to create custom Flipper Zero apps and scripts. It is specifically built against the Momentum Firmware SDK^[4] and includes:

Ready-to-use JavaScript script templates (basic-script.js, subghz-remote-template.js, gui-example.js)
C application templates (including a hello-world starter and a GUI Studio–generated example)
A real-world example Sub-GHz remote control (balkon-markise-remote.js)
Clear deployment instructions for both JS and .fap files
Integration notes for Flipper GUI Studio and uFBT

The goal is to make custom development on Flipper Zero more accessible, especially for beginners and mobile-first developers who may not have a development computer available.

Key Features

Dual Development Support — JavaScript (phone-friendly, no compilation) and C (native .fap, full hardware access)
Phone-Only Workflow — Edit and deploy JavaScript scripts from your phone using the Flipper Mobile App^[5] over Bluetooth — no computer needed
Templates & Examples — Basic scripts, Sub-GHz remote template, GUI app starters, and a real-world example
Hot Reload for JS — No compilation step — update the .js file on the SD card and re-run from the Flipper menu
C App Support — Full native .fap development with uFBT^[6] and optional Flipper GUI Studio integration
Documentation & Tooling — JS API reference, deployment guide, uFBT config notes, GUI tool integration guide, CI/CD automation
Weekly SDK Sync — A GitHub Actions workflow automatically syncs the JS SDK (@next-flip/fz-sdk-mntm^[4]) each week to track Momentum Firmware updates

Repository Structure

Flipper/
├── JS-Apps/
│   ├── templates/
│   │   ├── basic-script.js           # Minimal JS template
│   │   ├── subghz-remote-template.js # Sub-GHz remote with button menu
│   │   └── gui-example.js            # GUI widgets example
│   └── examples/
│       └── balkon-markise-remote.js  # Real awning/garage-door remote
├── C-Apps/
│   ├── templates/
│   │   ├── hello-world/              # Minimal .fap starter (build with uFBT)
│   │   └── gui-studio/               # GUI Studio–generated template
│   └── ufbt-config.md                # uFBT setup notes
├── docs/
│   ├── JS-API-Reference.md           # JavaScript SDK API reference
│   ├── deployment.md                 # Transfer methods and file paths
│   └── gui-tool-integration.md       # Flipper GUI Studio walkthrough
└── .github/workflows/
    └── (CI, release-please, weekly SDK sync)

JavaScript vs C Development Paths

	JavaScript	C `.fap`
Difficulty	Beginner-friendly	Advanced
Computer needed	No (phone sufficient)	Yes (uFBT toolchain)
Compilation	None	Required (`ufbt`)
Best for	Sub-GHz remotes, GUIs, automation	Drivers, performance-critical apps
Hot reload	Yes (copy file, re-run)	No (rebuild and redeploy)
SDK	`@next-flip/fz-sdk-mntm`^[4]	Momentum Firmware C headers

For most new users, the JavaScript path is the right starting point. The C path exists for cases where native hardware access or higher performance is genuinely required.

Getting Started: JavaScript Path

No computer required. You need:

A Flipper Zero running Momentum Firmware^[3]
The Flipper Mobile App^[5] (iOS/Android, connects over Bluetooth)
Any phone text editor (e.g. Acode, Quoda, or the GitHub web editor)

Steps:

Pick a template from JS-Apps/templates/ — start with basic-script.js or subghz-remote-template.js.
Edit it on your phone: change the script name, add your logic or Sub-GHz file paths.
Open the Flipper Mobile App, navigate to SD Card → apps → Scripts/, and upload your .js file.
On the Flipper: go to Apps → Scripts → [your_script.js] and run it.

To update, re-upload the file and re-run. No compilation, no cable required.

Getting Started: C Path

C app development requires a computer (or GitHub Codespaces for a browser-based environment).

One-time setup (install uFBT and sync the Momentum SDK):

pip install --upgrade ufbt
ufbt update --index-url=https://up.momentum-fw.dev/firmware/directory.json --channel=release

Build the hello-world template:

cd C-Apps/templates/hello-world
ufbt

The compiled .fap file is output to the dist/ directory. Copy it to the Flipper’s SD card under /ext/apps/Examples/ (or another category folder).

Alternative: Use GitHub Codespaces to open the repo in a cloud environment — uFBT installs in the devcontainer and you get a full build environment without local setup.

Deployment Destinations

App type	SD card location
JavaScript `.js` scripts	`/ext/apps/Scripts/`
C `.fap` apps	`/ext/apps/<Category>/`
Sub-GHz signal files `.sub`	`/ext/subghz/`

Transfer methods (all three are equivalent — choose by what you have available):

Flipper Mobile App (Bluetooth, phone-friendly) — drag-and-drop file browser
qFlipper^[7] (USB or Bluetooth, desktop app) — file manager for Windows/macOS/Linux
microSD card reader — pull the card, copy files directly, reinsert

Featured Example: Sub-GHz Remote

balkon-markise-remote.js is the real-world example in JS-Apps/examples/. It demonstrates a polished 3-button Sub-GHz remote with commands labelled REIN (in), RAUS (out), and STOP — designed for controlling a balcony awning or garage door.

The pattern it demonstrates is the canonical Sub-GHz JS workflow:

Pre-record raw .sub signal files for each button using the Flipper’s Sub-GHz app.
Store the .sub files on the SD card at /ext/subghz/.
Write a JavaScript script that presents a menu and calls subghz.transmitFile(path) for the chosen action.

This makes the Flipper act as a universal remote for any RF device you have physical access to record — no hardcoded frequencies or vendor dependencies.

GUI Studio Integration

For developers who want a graphical UI in their .fap apps without hand-writing C layout code, the framework documents integration with Flipper GUI Studio — available at tools.ranzlappen.com/tools/flipper-gui/.

The workflow:

Design the app’s screens by dragging widgets in the browser-based GUI Studio.
Configure app metadata (name, icon, author).
Export a complete C app bundle (.c + .h + application.fam).
Build immediately with ufbt from the exported directory.

The C-Apps/templates/gui-studio/ template in the repo shows the generated structure you can expect.

CI/CD & Automation

The .github/workflows/ directory provides:

Build CI — Runs ufbt on every pull request to verify C app templates compile cleanly against the current Momentum SDK.
Release automation — Uses release-please to create versioned GitHub releases when changes are merged to main.
Weekly SDK sync — A scheduled workflow runs ufbt update weekly to pull in the latest Momentum Firmware SDK release (currently mntm-012^[3]), ensuring templates stay buildable as the firmware evolves.

Security & Responsible Use

The Flipper Zero’s Sub-GHz, NFC, RFID, and IR capabilities can interact with a wide range of real-world devices. A few notes on responsible use:

Only record and replay signals from devices you own or have explicit permission to control. Replaying signals to third-party devices (e.g. neighbours’ garage doors) is illegal in most jurisdictions.
Momentum Firmware^[3] ships with region-based Sub-GHz frequency restrictions. Respect the legal frequency limits in your country.
The balkon-markise-remote.js example records raw .sub files from your own physical remote — it does not brute-force or guess codes.
JavaScript scripts on the Flipper run with access to hardware peripherals. Review any script you download from the internet before running it.

Key Takeaways

The Flipper repository is a development framework and starter kit — not an app or firmware itself.
JavaScript development can be done entirely from a phone with no computer required, using the Flipper Mobile App^[5] for Bluetooth file transfer.
C development via uFBT^[6] is supported for native .fap applications requiring hardware access or higher performance.
A real-world Sub-GHz remote example (balkon-markise-remote.js) demonstrates the recommended pattern for phone-controlled RF remotes.
Weekly automated SDK sync keeps templates buildable as Momentum Firmware^[3] evolves.
GUI Studio integration lets you design .fap app screens visually and export ready-to-build C bundles.

Conclusion

The Flipper repository stands out as one of the more approachable ways to start developing for the Flipper Zero. By offering both a simple JavaScript path (phone-friendly, no compilation) and a full C path (native .fap with hardware access), it caters to a wide range of users — from complete beginners experimenting from their phone to more experienced embedded developers building production tools.

If you own a Flipper Zero running Momentum Firmware and want to build your own tools, scripts, or applications, this framework is an excellent place to begin.

More project showcases: Ticked · MoodRadar · Discord Music Bot · HardwareDash · Pageside · tools.ranzlappen.com

Sources

Discord Music Bot: A Lightweight Self-Hosted Python Bot for YouTube & Local Music

2026-06-04T00:00:00+00:00

Introduction

The Discord Music Bot is a lightweight, self-hosted Python application that brings music playback directly into your Discord server. It supports both YouTube (videos and playlists) and local audio files, with an intuitive interactive control panel, queue management, text-to-speech, and convenient download/upload features.

Built with discord.py^[3], yt-dlp^[4], and gTTS^[5], it offers a clean slash-command experience and runs on any machine with Python 3 and FFmpeg^[6] installed. A pre-built Windows .exe is available in the releases for those who prefer not to manage a Python environment.

Repository: github.com/Ranzlappen/discord-musicbot

Key Features

YouTube & Local Playback — Stream YouTube videos or playlists via URL, or play from a local music/ folder.
Interactive Control Panel — A persistent embed with colour-coded buttons: play/pause (green), skip (blue), queue view (blue), autoplay toggle (blue/grey), volume ±5%, and more.
Queue Management — Configurable max queue size (default 100), per-track skip, full queue clear, and paginated queue browser.
Autoplay — Per-server autoplay that randomly picks local files when the queue runs empty.
Text-to-Speech (TTS) — Speak any text in the voice channel with 30+ language options. Music fades out, TTS plays, then music resumes at the same position.
Song Download & Upload — Download the currently playing song or any track from the queue/local library directly into Discord.
Admin Tools — /__clear_channel__ purges all messages in the current channel (requires Manage Messages permission).

How It Works

The bot authenticates with Discord using a bot token via discord.py’s slash-command framework^[3]. When a user runs /play <youtube-url>, the bot calls yt-dlp^[4] with format: bestaudio/best to extract a direct audio stream URL, then passes that URL to FFmpeg^[6] for real-time audio processing and playback into the Discord voice channel.

For playlists, yt-dlp first runs a flat extraction (extract_flat: True) to enumerate playlist entries, then streams them one by one from the queue.

For local files, the music/ directory is enumerated at startup. /local lists available files; /autoplay toggles random local playback when the YouTube queue is empty.

TTS works via gTTS^[5] (Google Text-to-Speech, v2.5.4 as of late 2024): the bot generates an mp3 file from the text, fades out the current track, plays the speech file through FFmpeg, then restores music.

The control panel embed is sent by /controls as a persistent Discord message with interactive buttons. The view has timeout=None (no expiry) — buttons work indefinitely until the bot restarts. Paginated file selectors use a timeout=120 seconds.

Architecture & Tech Stack

Component	Library / Tool	Role
Discord API	discord.py v2^[3]	Slash commands, voice, embeds, buttons
Audio extraction	yt-dlp^[4]	YouTube stream URL extraction
Audio processing	FFmpeg^[6]	Decode, transcode, stream to Discord
Text-to-speech	gTTS 2.5.4^[5]	Convert text to mp3 via Google TTS API
Configuration	`config.json`	Token, queue size, TTS defaults
Local library	`music/` folder	MP3 files for local playback & autoplay

FFmpeg options used at runtime:

# YouTube streaming
before_options: ‘-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5 -nostdin’
options: ‘-vn’

# Local file playback
before_options: ‘-nostdin’
options: ‘-vn’

The -reconnect flags handle transient network hiccups during long streams without the bot falling silent. -vn strips video so only the audio stream is processed.

File structure expected on disk:

your-folder/
├── discordmusicbot.py   # Bot entry point
├── config.json          # Configuration (see below)
└── music/               # Local MP3 library
    ├── song1.mp3
    └── ...

Command Reference

Command	Description	Notes
`/play <url>`	Stream a YouTube video or playlist	Supports full playlist URLs
`/local`	List all local MP3 files	Paginated selector
`/skip`	Skip the current track	Also available via control panel
`/pause`	Pause playback
`/resume`	Resume paused playback
`/join`	Bot joins your voice channel	Optional: clears queue on join
`/clearqueue`	Clear the entire song queue
`/autoplay`	Toggle per-server autoplay from local library	Does not affect other servers
`/download`	Download current song or choose from queue/library	Respects upload cooldown
`/tts <text>`	Text-to-speech in the voice channel	Max 500 chars; 30+ language options
`/controls`	Show the interactive control panel embed	Buttons are persistent
`/__clear_channel__`	Delete all messages in the channel	Requires `Manage Messages`

Configuration

All settings live in config.json in the same directory as discordmusicbot.py. The full default structure^[1]:

{
  "BOT_TOKEN": "YOUR BOT TOKEN",
  "EMBED_TITLE": "Music Controls",
  "EMBED_DESCRIPTION": "Use the buttons below to control music.",
  "EMBED_IMAGE_URL": "https://fonts.gstatic.com/s/e/notoemoji/latest/1f916/512.webp",
  "COOLDOWN_PER_UPLOAD_IN_SECONDS": 10,
  "MAX_SONG_QUEUE": 100,
  "MESSAGE_CLUTTER_REMOVAL_DELAY": 5,
  "DEFAULT_TTS_LANGUAGE": "en"
}

Field	Default	Description
`BOT_TOKEN`	—	Your Discord bot token from the Developer Portal
`EMBED_TITLE`	`"Music Controls"`	Heading of the control panel embed
`EMBED_DESCRIPTION`	`"Use the buttons…"`	Subtext in the control panel embed
`EMBED_IMAGE_URL`	robot emoji WebP	Thumbnail shown in the control embed
`COOLDOWN_PER_UPLOAD_IN_SECONDS`	`10`	Rate-limit on song downloads per user
`MAX_SONG_QUEUE`	`100`	Maximum tracks allowed in the queue
`MESSAGE_CLUTTER_REMOVAL_DELAY`	`5`	Seconds before ephemeral status messages are auto-deleted
`DEFAULT_TTS_LANGUAGE`	`"en"`	Default language for `/tts` (BCP 47 code)

Getting Started

Install FFmpeg and add it to your system PATH (required for audio processing).
Install Python dependencies:
```
pip install -U discord.py yt-dlp gTTS
```
Create a Discord Application at the Discord Developer Portal, generate a bot token, and enable the Message Content and Server Members intents.
Edit config.json — paste your token into BOT_TOKEN. Adjust MAX_SONG_QUEUE, DEFAULT_TTS_LANGUAGE, etc. as needed.
Invite the bot to your server with these permissions: Connect, Speak, Send Messages, Embed Links, Attach Files, Use Slash Commands, Manage Messages (for /__clear_channel__).
Run the bot:
```
python discordmusicbot.py
```

The bot goes online and registers slash commands. Use /controls in any text channel to post the persistent control panel embed.

Windows shortcut: A pre-built .exe is available in the releases — download, place config.json and your music/ folder alongside it, and double-click to run without needing Python installed.

Troubleshooting & Pitfalls

Bot joins the voice channel but no audio plays
FFmpeg must be on your system PATH. Run ffmpeg -version in a terminal to verify. If the command is not found, install FFmpeg and add its bin/ directory to PATH.

YouTube playback stops mid-stream with no error
The -reconnect FFmpeg flags handle most network blips, but very long streams or throttled connections can still drop. Use /skip and re-queue the track if this happens.

Heavy YouTube usage warning
The README explicitly notes that heavy YouTube usage may trigger rate limiting or temporary account flags on the IP running the bot. Self-hosting on a residential connection is usually fine for personal/small-server use.

Buttons no longer respond after a bot restart
The control panel embed is re-registered at runtime. After restarting the bot, run /controls again to post a fresh embed with live button listeners.

TTS message is cut off
/tts has a hard 500-character limit. Split long texts into multiple commands.

Autoplay does not trigger
Autoplay requires at least one MP3 file in the music/ folder and must be toggled on per-server via /autoplay.

Security Notes

Never commit config.json to a public repository. The BOT_TOKEN field is a secret credential. The README includes this warning explicitly^[1]. Add config.json to your .gitignore before making any fork public.
The bot uses /__clear_channel__ (double underscore) as a deliberate naming convention to make it harder to trigger accidentally; it also requires the Manage Messages Discord permission.
The bot operates with minimal permissions — only what is listed in the invite URL. Do not grant Administrator unless you have a specific reason.
The download feature streams file uploads into Discord and is rate-limited by COOLDOWN_PER_UPLOAD_IN_SECONDS to prevent abuse.

Key Takeaways

A lightweight, self-hosted Discord music bot written in Python that supports both YouTube and local MP3 files.
Features an interactive button control panel with persistent embeds — no need to remember command names for day-to-day use.
Includes per-server autoplay, TTS with music-pause, paginated queue browser, and easy song downloading.
Simple one-file setup with config.json — easy to run locally, on a server, or via the Windows .exe release.
Fully open-source (MIT) with a straightforward architecture built on discord.py^[3], yt-dlp^[4], gTTS^[5], and FFmpeg^[6].

Conclusion

The Discord Music Bot is a practical, no-nonsense solution for adding music to your Discord server without relying on third-party hosted bots. Its combination of YouTube and local file support, interactive controls, TTS integration, and easy self-hosting makes it a great choice for personal use or small communities. Full ownership of the bot means no surprise shutdowns, no premium tiers, and complete control over what it can do.

More project showcases: Ticked · MoodRadar · Flipper Zero Framework · Synth Piano · repo-standards · tools.ranzlappen.com

Sources

The Cookie Loophole-Loophole: Data Exploitation, User Powerlessness, and Abuse of the Essential Cookies Rule

2026-04-12T00:00:00+00:00

Introduction

Building on the intrusive advertising landscape and the mechanics of cookies in targeted tracking, the core failure is now even clearer. The GDPR (in German, the DSGVO) and the ePrivacy Directive require explicit, freely given consent for any non-essential cookies — Article 5(3) of the ePrivacy Directive forbids storing or accessing information on a user’s device without prior informed consent, except where strictly necessary.^[1] Yet websites systematically bypass these rules through deliberate design and outright abuse of exemptions. Regulators issue fines, companies absorb them as costs, and the data machine keeps running. The real story is user powerlessness: you cannot reject tracking, you cannot realistically “cease and desist”, and even successful actions change nothing. Companies further weaponize the strictly necessary cookies rule for invasive behavior that requires no consent at all. This is the cookie loophole-loophole — laws on paper, zero accountability in practice.

The scale of the problem is not anecdotal. Since 2021 the privacy NGO noyb (founded by Max Schrems) has filed more than 700 formal complaints against deceptive cookie banners, and in January 2023 the European Data Protection Board’s Cookie Banner Taskforce published a report cataloguing exactly the patterns described below — missing “reject” buttons on the first layer, pre-ticked boxes, refusal links buried in body text, and deceptive button contrast.^[2] The practices are documented at the highest regulatory level; what is missing is consequence.

The Cookie Loophole-Loophole Explained

The first loophole is the assumption that any cookie banner equals compliance. The double loophole is the reality that banners can be engineered to look compliant while violating GDPR Article 7 in spirit and substance. Article 7(3) is explicit that “it shall be as easy to withdraw as to give consent,” and Article 7(4) treats consent as suspect wherever access to a service is conditioned on accepting data processing that is not necessary to provide it.^[3] Consent, in other words, must be freely given, specific, informed, unambiguous — and just as revocable as it was grantable. Dark patterns create the illusion of choice while guaranteeing acceptance. The system is built so that users have no real agency, and enforcement never forces systemic change.

GDPR Non-Conformity Tactics in Practice

Websites deploy a recurring toolkit of dark patterns, every one of which appears in the EDPB Cookie Banner Taskforce’s own catalogue of harmful practices:^[2]

Asymmetric button design: a large, colorful “Accept All” next to a tiny, grayed-out “Reject,” or a “Reject” path hidden behind multi-click preference menus. The European Court of Justice’s Planet49 ruling (C-673/17) already established that consent cannot be obtained through pre-ticked boxes.^[4]
Pre-ticked or implied consent: non-essential cookies load before any user interaction — flatly incompatible with the requirement for prior opt-in.
Legitimate interest abuse: labeling advertising and analytics as “legitimate business interest” to skip the consent step. When noyb first challenged this, 22% of contacted companies quietly dropped their “legitimate interest” claims rather than defend them.^[5]
Pay-or-consent (“Pay or Okay”) walls: no genuine free alternative to tracking. The EDPB’s Opinion 08/2024 held that, in most cases, large online platforms cannot obtain valid consent by offering only a binary “consent to tracking or pay a fee” choice, and stressed that personal data “cannot be considered a tradeable commodity.”^[6]
Server-side tracking workarounds: scripts still fire regardless of the consent signal, because the tracking now happens on the server where the browser’s choice cannot reach it.

These tactics persist because they generate revenue far exceeding any enforcement risk.

Abuse of the Strictly Necessary Cookies Rule: Invasive Behavior Without Consent

One of the most invasive behaviors is the deliberate abuse of the “strictly necessary” or “essential” cookies exemption. GDPR explicitly limits this category to cookies required for the site to function: basic authentication, shopping cart memory, security features, or load balancing. Everything else — analytics, personalization, advertising, or cross-site tracking — requires consent.

In practice, many websites falsely classify tracking scripts, fingerprinting, audience measurement, or even social media pixels as “essential.” This removes any consent prompt entirely. Users never see a banner for these cookies because the site simply declares them necessary. The result is fully invasive data collection with zero user input or visibility. Performance cookies, session replay tools, and ad retargeting are routinely mislabeled this way, turning the exemption into a blanket license for surveillance. Regulators have repeatedly called out this practice, yet it remains widespread because it eliminates the friction of consent entirely while delivering the same valuable user profiles.

The Shein case is a textbook illustration of the gap between the rule and the practice. The CNIL found that advertising cookies were placed on visitors’ devices as soon as they arrived on shein.com — before any interaction with the banner — and that when a user clicked “Refuse all” or withdrew consent, new cookies were still written and existing ones still read.^[7] In other words, the “reject” button was decorative: the strictly-necessary fiction operated underneath it the whole time. That a €150 million penalty was needed to establish something the law already plainly required shows how far the default has drifted from compliance.

User Powerlessness: Why You Cannot Reject or "cease and desist"

Ordinary users are structurally powerless.

You cannot reject. The “Reject” option is deliberately hidden, requires navigating confusing sub-menus, or leads to degraded site functionality. Many banners simply ignore the rejection and continue loading trackers. Technical verification is impossible for non-experts; you have no way to confirm whether your choice was honored. When sites abuse the essential cookies rule, there is not even a reject button to begin with.

You cannot realistically issue a “cease and desist.” In Germany the Abmahnung (a formal warning / cease-and-desist) is theoretically available to consumer associations and, in some contexts, competitors. In practice it is expensive, time-consuming, and legally risky. You must document the violations, hire lawyers or rely on the overburdened Verbraucherzentrale, and often face counter-claims or procedural hurdles. Crucially, GDPR enforcement runs primarily through the supervisory authorities, not individuals: an ordinary user’s main lever is a complaint to a data-protection authority under Article 77, after which an under-resourced regulator may or may not act, often years later.^[8] Most individuals give up before filing. Even when consumer organizations bring coordinated actions, the typical response is a minimal banner tweak or a small settlement — not structural reform.

Even successful actions change nothing at scale. One user’s complaint or one “cease and desist” is treated as noise. Companies simply update the banner slightly or re-label trackers as “essential” and resume operations. The asymmetry is total: you invest hours or euros; they absorb it as a rounding error.

What Enforcement Actually Looks Like: Real Cases

The abstract pattern becomes concrete in the enforcement record. A non-exhaustive sample:

Google — €325 million (CNIL, September 2025). Two fines (€200M against Google LLC, €125M against Google Ireland) for inserting advertisements between Gmail messages and placing advertising cookies during account creation through asymmetric “dark pattern” design that made refusal harder than acceptance. The cookie breach alone touched more than 74 million accounts; 53 million people saw the disguised ads. The case grew out of a 2022 noyb complaint.^[9]
Shein — €150 million (CNIL, September 2025). Advertising cookies dropped before any banner interaction; cookies still written and read after a “Refuse all” click; incomplete information in the banner — affecting an average of 12 million French visitors per month.^[7]
Earlier CNIL precedents. France previously fined Google €150 million and Facebook €60 million (December 2021) for making it harder to refuse cookies than to accept them — establishing the “reject must be as easy as accept” principle years before the 2025 fines, which shows how little changed in the interim.^[10]

Two patterns jump out. First, the same company (Google) is fined for the same category of conduct (cookies dropped or nudged without valid consent) across multiple years — proof that a nine-figure penalty did not change the underlying behavior. Second, almost every headline case traces back to an NGO complaint, not to proactive regulatory monitoring; without noyb feeding cases into the system, much of this would never surface at all.

Fines Paid, Yet Zero Accountability

GDPR enforcement has generated roughly €7.1 billion in fines since 2018, with about €1.2 billion in 2025 alone, and over 60% of the total imposed since January 2023.^[11] High-profile cases — Google (€325 million in France), Shein (€150 million) — make headlines. Yet fines function as a licensing fee for bad behavior. For a firm whose advertising business is measured in the tens of billions per quarter, even a record nine-figure penalty is a rounding error. No executives face personal liability. Stock prices rarely dip. Data collection resumes within weeks under slightly different wording or reclassified essential cookies. Cross-border cases drag on for years under the GDPR’s “one-stop-shop” mechanism while the exploitation continues uninterrupted. There is no mechanism that forces companies to stop; accountability is, for practical purposes, fictional.

This article opens the privacy-and-control series and connects directly to the media-trust thread on advertising:

The Atrocious Intrusive Landscape of Advertising — the economic engine that makes cookie tracking worth fighting to preserve, including the same Google and Shein fines viewed from the ad-industry side.
Dark Mode for Pros, Light Mode for Everyone — a companion piece on giving users genuine control over their own experience rather than dictating it.

Key Takeaways

GDPR/DSGVO and the ePrivacy Directive demand explicit, freely given consent (Articles 7 and 5(3) respectively), yet dark patterns catalogued by the EDPB's own taskforce make real rejection practically impossible.^[2]^[3]
Websites falsely label tracking, analytics, and advertising scripts as “essential,” enabling fully invasive behavior without any consent prompt — as the Shein decision documented in detail.^[7]
Individual complaints (Article 77) and cease-and-desist routes are expensive, slow, and ineffective; even successful cases produce only cosmetic changes.^[8]
Companies treat fines as operational costs: Google was penalized for materially the same cookie conduct in 2021 (€150M) and again in 2025 (€325M), with the practice persisting in between.^[9]^[10]
No personal accountability exists for decision-makers; users bear the full burden with zero meaningful recourse.

Conclusion

The cookie loophole-loophole exposes a consent regime that protects corporations, not citizens. You cannot reject, you cannot “cease and desist” effectively, and even when the system occasionally moves it changes nothing. Abuse of the essential cookies rule adds another layer of invasive behavior that bypasses consent entirely. Fines are paid, behavior continues, and accountability is absent. Until regulators impose personal liability, automatic technical enforcement, and direct user remedies, the data exploitation machine will keep running exactly as designed — with users having no real way to stop it.

Sources

ePrivacy Directive 2002/58/EC, Article 5(3) (consent for storing/accessing information on terminal equipment) — EUR-Lex.
European Data Protection Board — Report of the work undertaken by the Cookie Banner Taskforce (Jan 2023). Context on noyb's 700+ complaints via noyb.
GDPR (Regulation (EU) 2016/679), Article 7 — Conditions for consent — gdpr-info.eu.
Court of Justice of the EU, Planet49 (C-673/17, 1 Oct 2019) — pre-ticked boxes do not constitute valid consent — judgment on EUR-Lex.
noyb — noyb files 422 formal GDPR complaints on nerve-wrecking "Cookie Banners" (22% of companies dropped "legitimate interest" claims after challenge).
European Data Protection Board — Opinion 08/2024 on Valid Consent in the Context of "Consent or Pay" Models.
CNIL — Cookies placed without consent: SHEIN fined €150 million (Sept 1, 2025).
GDPR Article 77 — Right to lodge a complaint with a supervisory authority — gdpr-info.eu.
CNIL — Cookies and advertisements inserted between emails: GOOGLE fined €325 million (Sept 1, 2025).
CNIL (Dec 31, 2021) — Google fined €150 million (and Facebook €60 million) for making cookie refusal harder than acceptance: Google decision, Facebook decision.
DLA Piper — GDPR Fines and Data Breach Survey: January 2026 (cumulative ~€7.1B since 2018; ~€1.2B in 2025; 60%+ since Jan 2023).

The Evolution of Automation: From Ancient Tools to AI-Driven Systems Through Human History

2026-04-11T00:00:00+00:00

Introduction

The concept of automation has shaped human progress for millennia. It represents humanity’s enduring drive to reduce manual labor, increase efficiency, and extend capabilities through machines that operate with minimal or no human intervention. From prehistoric levers and water wheels to today’s AI systems that make decisions and learn autonomously, automation has evolved in parallel with technology, society, and economic needs. This journey reflects not only technological innovation but also shifts in how humans view work, creativity, and control.

A useful way to read the timeline below is as a slow migration along two axes at once: from augmenting muscle (lifting, grinding, pumping) toward augmenting mind (deciding, planning, learning), and from fixed behavior baked permanently into hardware toward flexible behavior that can be reprogrammed — and, most recently, that reprograms itself. Almost every milestone in this article can be located somewhere on those two axes, and the overall direction of travel never reverses.

It helps to define the term before tracing it. Encyclopaedia Britannica describes automation as “the application of machines to tasks once performed by human beings or, increasingly, to tasks that would otherwise be impossible,”^[2] and classifies industrial automation into three families: fixed (or “hard”) automation, where the operation sequence is locked into the equipment; programmable automation, suited to batch production; and flexible automation, which can switch products with little downtime.^[2] That three-way split is a useful lens for the whole timeline below: each era of history pushed automation a little further along the path from fixed to flexible, and finally toward systems that reprogram themselves.

Ancient Origins: Simple Machines and Automata

Automation’s roots trace back over 5,000 years. Around the 4^th millennium BCE, Mesopotamians developed the wheel and axle, enabling carts and pottery wheels that reduced manual effort.^[1] Ancient civilizations created early powered mechanisms: Chinese trip-hammers driven by water automated grain processing and forging.^[2] Water wheels and windmills performed repetitive tasks such as irrigation and milling without constant human input. Even imperial Rome practiced a primitive form of feedback control — Britannica notes that the regulation of liquid level using a float was practiced in antiquity and that such float-valve mechanisms are the conceptual ancestors of modern feedback control,^[2] a self-regulating loop identical in principle to the float in a modern toilet cistern. These were not “smart” machines in any modern sense, but they crossed a crucial line: a device that adjusts its own behavior in response to its environment, without a human in the loop, is doing the essential thing automation does.

Philosophers and inventors imagined more advanced forms. Greek myths described Hephaestus forging metal automata as servants — the bronze giant Talos, who patrolled the shores of Crete three times a day, and the golden handmaidens of his workshop — making antiquity’s storytellers, not just its engineers, the first to dream of artificial labor.^[5] By the 3^rd century BCE, Hellenistic engineers such as Ctesibius of Alexandria built water-powered organs and pneumatic devices that demonstrated programmable mechanical action. In ancient Egypt, Greece, and Rome, engineers built mechanical statues and temple devices that moved autonomously through hidden siphons, weights, and steam, serving religious, entertainment, or practical purposes.^[5] Hero of Alexandria, writing in the 1^st century CE, catalogued automatic temple doors, coin-operated dispensers (a holy-water vending machine), self-trimming lamps, and even programmable theatres in his treatise On Automata.^[5] These early automata embodied the concept of machines acting of their own will — and established a pattern that recurs throughout this history: the idea of automation almost always precedes the practical means to build it. The Greeks could imagine Talos millennia before anyone could build a machine that walked, and even Hero’s working automata were powered theatre, not productive labor. The gap between dream and deployment would narrow steadily, but it never fully closes — it simply moves to the next frontier.

Medieval and Renaissance Advances

The Middle Ages and Islamic Golden Age advanced mechanical ingenuity. Windmills with automatic sail-turning mechanisms spread across Europe and the Middle East. The mechanical clock, developed in the 14^th century in Europe, used weights, gears, and the escapement for self-regulating timekeeping^[1] — arguably the first widely deployed machine whose entire purpose was to run on its own, unattended, for days at a time. In Baghdad’s House of Wisdom around 850 CE, the three Banū Mūsā brothers compiled the Book of Ingenious Devices (Kitāb al-Ḥiyal), describing roughly one hundred mechanisms — trick vessels, fountains, and an automatic flute player often called the first programmable machine — many using automatic valves and rudimentary feedback control powered by water and weights.^[9] Three centuries later, the engineer al-Jazarī extended this tradition with elaborate water clocks and humanoid automata.

During the Renaissance, Leonardo da Vinci sketched designs for self-propelled carts and a mechanical knight around 1495, apparently assembled and displayed for the first time at the Milanese court of Ludovico Sforza; operated by a system of pulleys and cables, the armored automaton could sit, stand, raise its visor, and move its arms — two independent linkage systems gave it three degrees of freedom in the legs and four in the arms.^[10] The design was reconstructed in working form only after Leonardo’s sketches resurfaced in the 1950s. Leonardo’s spring-driven self-propelled cart — sometimes called the first “robot car” — even followed a pre-set steering program set by pegs, making it a mechanical ancestor of the programmable machine. These conceptual automata pushed the boundary between tool and independent machine, laying groundwork for programmable systems centuries before the engineering existed to make them reliable.

The Industrial Revolution: Mechanization Takes Hold

The late 18^th and early 19^th centuries marked a pivotal shift. James Watt’s improved steam engine, patented in 1769, powered factories and enabled mechanized production at a scale water wheels never could.^[2] Watt’s later addition of the centrifugal flyball governor — which automatically throttled steam to hold engine speed steady as load changed — is often cited as the first widely industrialized feedback-control device, a direct descendant of those ancient float valves and a direct ancestor of every thermostat and cruise control since.

The Jacquard loom, demonstrated around 1801 by Joseph-Marie Jacquard in Lyon, used a chain of punched cards to program complex woven patterns, with the holes determining which warp threads lifted on each pass of the shuttle.^[3] This was a conceptual leap as important as any engine: it separated the machine from the instructions, so that changing the cards changed the product without rebuilding the loom. Charles Babbage borrowed exactly this punched-card idea for the input of his proposed Analytical Engine, and Herman Hollerith later used punched cards to tabulate the U.S. census — a lineage that runs straight from a silk loom to the early data-processing industry.^[3]

Oliver Evans built a highly automated flour mill in the 1780s in which bucket elevators and conveyors moved grain through the entire process with little manual handling, an early example of continuous, integrated production.^[1] Together these developments replaced human and animal power with mechanical force on a massive scale, birthing the factory system and transforming economies — and, for the first time, provoking organized anxiety about machines displacing workers (the Luddite protests of 1811–1816 were a reaction to precisely this kind of textile automation).

Early 20th Century: Assembly Lines and the Birth of Modern Automation

Henry Ford’s moving assembly line, run for the first time across the whole Highland Park plant on 7 October 1913, revolutionized manufacturing. By bringing the work to stationary workers rather than moving workers to the work, it cut the time to assemble a Model T chassis from roughly 12.5 hours to about 93 minutes within a year.^[3]^[4] The productivity gain let Ford slash the car’s price and pay the famous $5 day — a vivid early illustration of a pattern that recurs throughout automation’s history: mechanization can raise wages and lower prices even as it deskills and intensifies individual jobs. Note, too, what the assembly line was not: it was not autonomous. It was fixed automation in the purest sense — the sequence was locked into the physical layout of the line, and any change of product meant retooling the whole plant.

Electrification and interchangeable-parts standardization further scaled output, and World War II accelerated innovation with automated production of military equipment. The word “automation” itself was popularized around 1946–1947 by Ford’s Delmar S. Harder, who used it for the company’s new “Automation Department” charged with mechanizing the handling of parts between machines.^[2] Tellingly, the term was coined to describe moving things automatically, not thinking automatically — the cognitive frontier was still decades away.

Mid-20th Century: Computers, Robots, and the Term Automation

The 1950s and 1960s integrated electronics and computing. George Devol filed his patent for a “Programmed Article Transfer” in 1954 (granted 1961); with Joseph Engelberger he founded Unimation, and their Unimate became the first industrial robot when one was installed on a General Motors die-casting line in New Jersey in 1961.^[6]^[7] The 4,000-pound arm obeyed pre-programmed commands stored on a magnetic drum to lift and quench hot die-castings and spot-weld bodies — dangerous work that had poisoned and maimed human operators.^[7] Crucially, Unimate was programmable automation, not fixed: you could teach it a new motion sequence without rebuilding the machine, which is exactly what made the robot, rather than the conveyor, the seed of a new industry.

In parallel, the electronic computer arrived: ENIAC (1946) realized in vacuum tubes the kind of general-purpose computation Charles Babbage had only been able to design on paper a century earlier.^[2] Programmable logic controllers (PLCs), introduced in the late 1960s to replace banks of hard-wired relays, gave factory floors reliable, reprogrammable control. The Stanford Arm (1969) introduced an all-electric, computer-controlled robotic arm with the kinematics and feedback that made precise, sensor-guided manipulation practical.^[6] Together these threads — the programmable robot, the general-purpose computer, and reprogrammable factory control — converged into what we now simply call “automation.”

The Digital Age and Rise of Robotics

From the 1970s onward, microprocessors and integrated circuits miniaturized and accelerated automation.^[8] Europe entered the field decisively in 1973–1974: Germany’s KUKA built FAMULUS, among the first articulated robots with six electromechanically driven axes (a configuration that remains the most common industrial-robot kinematic today), and Sweden’s ASEA — later part of ABB — shipped the IRB 6, the world’s first commercially available all-electric, microprocessor-controlled industrial robot.^[11] Industrial robots from ABB, KUKA, and FANUC went on to spread globally.^[7]

The 1980s and 1990s brought computer numerical control (CNC) machines, machine-vision systems, and force/torque sensors, giving machines a crude sense of sight and touch and closing the perception–action loop that earlier robots lacked. Robotic process automation (RPA) later extended the same idea to pure software — scripting the keystrokes and form-filling of back-office data entry — so that “automation” no longer required any moving parts at all. Automation moved well beyond the factory into logistics, agriculture, finance, and consumer services.

The AI Era: Intelligent Automation Today

The 21^st century fused automation with artificial intelligence, and in doing so crossed the long-anticipated line from augmenting muscle to augmenting mind. Where classical automation executed a fixed or pre-programmed sequence, machine-learning systems infer their own rules from data — they adapt, predict, and optimize without an engineer specifying every step in advance. This is the closest the timeline has yet come to the self-reprogramming machine that the fixed → programmable → flexible progression always pointed toward.

The practical consequences arrived quickly. Collaborative robots (cobots) trade raw speed for force-limited safety so they can share a workspace with people instead of being caged off from them. AI-driven platforms now automate genuinely cognitive work: triaging support tickets, screening medical images, routing freight, detecting fraud, drafting and summarizing text, and generating images and code. As of 2026, the stack spans edge inference on the factory floor, large models in the cloud, and increasingly autonomous agents that chain tasks together with minimal supervision. The focus has shifted from mere mechanization to systems that improve with use — but the shift also reopens older questions in sharper form: when a system learns its behavior rather than having it specified, accountability, bias, and explainability become engineering problems, not just philosophical ones.

The Recurring Pattern: Labor, Fear, and Adaptation

Read end to end, the history of automation is less a straight line of gadgets than a repeating cycle. A new technology automates a category of work; the workers in that category fear (often correctly) for their immediate livelihoods; the economy absorbs the change over a generation, usually creating new categories of work that did not previously exist; and the cycle resets one rung higher on the ladder from muscle toward mind.

Antiquity to the loom: the idea of artificial labor (Talos, Hero’s theatres) long preceded any machine that could actually displace a worker. Fear was philosophical, not economic.
The Industrial Revolution: for the first time, automation displaced workers at scale and provoked organized resistance — the Luddites smashing textile frames in 1811–1816. Yet textile employment ultimately grew as cheaper cloth expanded demand.
The assembly line: Ford’s line destroyed the craft of the skilled coachbuilder but created millions of higher-paid (if more monotonous) factory jobs, and put cars within reach of the people who built them.^[4]
The computer and the robot: automation began consuming routine cognitive and manipulative work, hollowing out some middle-skill jobs while creating entire industries — software, robotics integration, logistics — that employ far more people than the robots replaced.
The AI era: for the first time, automation targets non-routine cognitive work that was long assumed to be safely human. Whether the historical pattern of net job creation holds for work that automates judgment itself is the open question of our decade.

The lesson is not that “automation always creates more jobs than it destroys” — that is too glib, and the gains and losses rarely land on the same people. The durable lesson is about transition: the technology arrives faster than institutions, skills, and safety nets adapt, and the human cost is concentrated in that lag. Every era in this article that handled automation well did so by investing in the adaptation, not by stopping the machine.

Key Takeaways

Automation began with prehistoric simple machines and ancient automata designed to reduce labor and perform repetitive tasks.
The Industrial Revolution transformed the concept through steam power, programmable looms, and factories, replacing human muscle with mechanical force.
20th-century milestones including assembly lines, computers, and the first industrial robots formalized modern automation and coined the term itself.
Digital and AI eras have made automation adaptive, intelligent, and ubiquitous, extending far beyond physical manufacturing.
Each leap moved automation along two axes at once — from augmenting muscle toward augmenting mind, and from fixed behavior toward reprogrammable and now self-learning behavior.
Throughout history, automation has driven productivity gains while raising recurring questions about labor displacement and human purpose — and the human cost has consistently concentrated in the transition lag, not the technology itself.

Conclusion

The concept of automation has evolved from humanity’s earliest efforts to augment physical strength with tools to today’s sophisticated AI systems that replicate and exceed cognitive functions. Each era built upon the last, driven by the same core impulse: to achieve more with less direct human effort. As automation continues to advance, it challenges societies to balance efficiency with equity, creativity with control, and technological progress with human values. Understanding this long arc equips us to navigate the next phase responsibly.

Sources

Computer History Museum — "1801: Punched cards control Jacquard loom" (and the museum's broader timeline on early mechanization and information storage). Accessed 2026.
Encyclopaedia Britannica — "Automation | Technology, Types, Rise, History, & Examples", including the entries on fixed, programmable, and flexible automation. Accessed 2026.
Encyclopaedia Britannica — "Jacquard loom" and "Joseph-Marie Jacquard" (punched cards, programmability, and the link to Babbage and Hollerith). Accessed 2026.
Library of Congress — "Ford Implements the Moving Assembly Line", and HISTORY — "Moving assembly line debuts at Ford factory (October 7, 1913)". Accessed 2026.
Smithsonian Magazine — "Was Talos, the Bronze Automaton Who Guarded the Island of Crete in Greek Myth, an Early Example of Artificial Intelligence?" (on Hephaestus's automata, Talos, and Hero of Alexandria). Accessed 2026.
IEEE Spectrum — "In 1961, the First Robot Arm Punched In" (Unimate, Devol, Engelberger, and the Stanford Arm lineage). Accessed 2026.
The Henry Ford — "First Unimate Robot Ever Installed on an Assembly Line, 1961", with industry context from A3/Automate, "Unimate — The First Industrial Robot". Accessed 2026.
Encyclopaedia Britannica — "Automation — Manufacturing applications of automation and robotics" (microprocessors, CNC, vision, and the spread beyond the factory). Accessed 2026.
Wikipedia — "Book of Ingenious Devices" (the Banū Mūsā brothers, ~850 CE, and the automatic flute player as an early programmable machine). Accessed 2026.
Wikipedia — "Leonardo's robot" (the ~1495 mechanical knight, its pulley-and-cable linkages, and the 1950s rediscovery and reconstruction). Accessed 2026.
AllAboutLean — "KUKA FAMULUS Turns 50 — The First Modern Industrial Robot" (KUKA FAMULUS, 1973, and the ABB/ASEA IRB 6, the first all-electric microprocessor-controlled robot). Accessed 2026.

The Atrocious Intrusive Landscape of Advertising: Media Dependency, Real-World Overload, Escape Hurdles, Cookies, Targeted Data, and Sociological Impact

2026-04-04T00:00:00+00:00

Introduction

Western media’s structural failures, detailed in the prior pieces on independent journalism and partisan statistical slant, stem in large part from advertising dependency. The same economic model now drives an even more aggressive intrusion into daily life. Advertising saturates both digital platforms and physical environments with relentless intensity.^[1] Consumers encounter constant interruptions, sophisticated tracking mechanisms, and societal conditioning that normalizes overconsumption. Escaping this system demands deliberate, ongoing effort. At the same time, the model generates disposable corporate revenue for products that could compete on intrinsic value alone. This article examines the full scope of the problem, its trajectories, avoidance barriers, the mechanics of cookies and targeted data exploitation, the sociological forces at play, and the direct cost to users.

To keep the analysis honest, this piece also separates the claims that the evidence strongly supports — that ad spend is enormous, that intrusion is rising, and that cookie-based tracking persists in defiance of regulation — from the more contested question of whether advertising itself makes people measurably unhappier. The peer-reviewed literature on that last point is genuinely split, and a dedicated section below lays out both sides rather than cherry-picking the convenient result.

The Expanding Advertising Landscape in Media and the Real World

Digital media delivers the most immediate and personalized intrusion. Social feeds, streaming services, news sites, and apps insert repetitive video, banner, and native ads into every scroll or pause. Physical advertising has kept pace and evolved in tandem. Billboards, transit wraps, digital out-of-home screens, and even store interiors now deploy programmatic targeting and contextual relevance. Global advertising revenue crossed the one-trillion-dollar threshold for the first time in 2024 — GroupM put it at roughly $1.04 trillion (up 9.5% year over year), while WARC’s parallel forecast landed even higher at about $1.08 trillion — and digital platforms are on track to capture roughly 73% of that total by 2025, rising toward 77% by 2029.^[2] The market is also extraordinarily concentrated: pure-play internet platforms led by Alphabet (Google), Meta, and Amazon alone were forecast to absorb about $741 billion, nearly 69% of the entire global market, in 2024.^[2] Retail media (+21.3%), social (+14.2%), and search (+12.1%) drove the bulk of that growth. The result is an environment where advertising no longer feels like a side element but the dominant layer overlaying content and public space alike — and where a handful of firms set the rules for how attention is bought and sold.

The scale of consumer irritation tracks the scale of spend. In recent industry surveys, 91% of online users say ads have become more intrusive than in prior years, 87% feel there are simply more ads than ever, and 88% notice the same creative repeating.^[4] Two-thirds (66%) call the majority of digital ads they see irrelevant to their interests, and 43% say they now do everything they can to avoid or block ads outright.^[3]^[4]

The discomfort is not just about clutter; it is about being watched. Pew Research Center finds that 72% of Americans feel that all, almost all, or most of what they do online or on their phone is being tracked by advertisers and tech firms, and 81% say the potential risks of companies collecting their data outweigh the benefits.^[9] Roughly two-thirds (67%) report turning off cookies or website tracking specifically to protect their privacy.^[9] The trillion-dollar machine is, by its own audience’s account, working against the people it targets.

Trajectories of Intrusion and Escalation

The trajectory shows clear escalation on both fronts. Traditional media once confined ads to predictable breaks or side columns. Digital platforms eliminated those boundaries through algorithmic insertion, infinite scrolling, and auto-play. Real-world advertising shifted from static signage to data-driven, location-triggered displays that adapt in real time. This dual-front expansion creates a seamless attention economy optimized for frequency and engagement metrics rather than relevance or user benefit. The parallel development in media and physical spaces reinforces the sense of inescapability.

The Difficulty and Hurdles to Escape or Avoid Advertising

Avoidance now requires constant vigilance and technical workarounds. Browser extensions can block many online ads, yet publishers detect them and respond with paywalls, degraded experiences, or server-side ad delivery that circumvents client-side blockers. The arms race is visible in concrete moves: YouTube began throttling and warning ad-block users in 2023, and the deprecation of Chrome’s Manifest V2 extension platform — which Google began phasing out in mid-2024 and completed for general users by mid-2025 — broke the most powerful blockers (notably the original uBlock Origin, removed from the Chrome Web Store in late 2024) by replacing the broad webRequest API with the far more limited declarativeNetRequest, leaving Chrome users only the reduced-functionality uBlock Origin Lite.^[10] Streaming services have introduced anti-ad-block measures and increased ad loads even on paid tiers — Amazon Prime Video, for instance, switched its standard plan to ad-supported by default on January 29, 2024, and charged an extra $2.99/month (since raised to $4.99) to remove them.^[11] In physical environments, escape is practically impossible without avoiding urban centers, public transport, or commercial areas entirely; some jurisdictions have pushed back at the city level — São Paulo’s “Clean City Law” (Lei Cidade Limpa, enacted 2006 and effective from 2007) banned outdoor advertising outright and saw some 15,000 billboards taken down, and Grenoble removed municipal billboards in 2014 — but these remain rare exceptions.^[12]

Consumers routinely report ad fatigue: 66% describe the majority of ads they encounter as irrelevant, 39% as “excessive,” and 27% as outright “intrusive.”^[3]^[4] Nearly half (49%) have abandoned a purchase specifically because they saw a brand’s ads too often.^[4] The effort needed to curate even a partially ad-free existence underscores how deeply the system has embedded itself into everyday routines, and the publisher-side data shows the bad experiences cut both ways — degraded UX measurably erodes the very revenue the ads are meant to generate.^[8]

How Cookies Enable Targeted Advertising

Third-party cookies remain the foundational technology for cross-site tracking despite repeated privacy regulation attempts. They allow advertisers to follow users across unrelated domains, compiling detailed behavioral profiles from browsing history, search patterns, and purchase signals. After years of promising to kill them, Google reversed course: in July 2024 it abandoned the planned phase-out, and on April 22, 2025 it confirmed via the Privacy Sandbox blog that it would not even show a one-time consent prompt in Chrome — third-party cookies stay on, managed only through the existing buried Privacy and Security settings.^[5] Google had already pushed back the deprecation deadline three separate times since first announcing it in 2020 before scrapping it outright. That U-turn, made under heavy pressure from the ad industry, illustrates the sheer commercial gravity of these mechanisms. Alternatives such as first-party data collection, Google’s Privacy Sandbox APIs, and contextual targeting have emerged, but cookie-based systems continue to dominate because they deliver measurable return on investment.

The deeper mechanics of how that consent is solicited — the dark patterns, the abuse of the “strictly necessary” exemption, and why even successful complaints change nothing — are the subject of a dedicated follow-up: The Cookie Loophole-Loophole.

Targeted Ads Exploiting Intrusively Collected User Data and Research Status

A critical subsection concerns targeted ads that rely on intrusively collected user data. Research from 2025-2026 consistently shows these ads achieve higher short-term click-through rates yet provoke stronger negative reactions when users perceive them as surveillance. Privacy enforcement actions have increased, with regulators issuing fines for opaque consent practices (detailed in the next section). Industry studies report that repeated exposure to retargeted ads raises feelings of being watched (79 percent of respondents in recent surveys) and erodes overall trust in both brands and platforms.^[4] Pew’s broader findings corroborate the discomfort: a majority of Americans feel they have little or no control over the data companies collect, and only about 5% believe they benefit a great deal from that collection.^[9] The research status remains clear: while personalization drives immediate engagement metrics, it accelerates privacy backlash and long-term user disengagement. Cookie-dependent targeting persists precisely because it converts data into revenue, sustaining the arms race between trackers and privacy tools.

The Regulatory Backdrop: Fines That Read Like Receipts

Regulators have not been idle, but their interventions read more like an itemized cost of doing business than a deterrent. In September 2025 France’s data-protection authority, the CNIL, issued two of the largest cookie-consent penalties on record in the same week: €325 million against Google (€200 million against Google LLC and €125 million against Google Ireland) for inserting ads between Gmail messages and placing advertising cookies on more than 74 million accounts without valid consent, and €150 million against Shein’s Irish subsidiary for dropping advertising cookies before users interacted with the banner and continuing to read cookies even after a “Refuse all” click.^[13]^[14] Both cases originated from complaints by the privacy NGO noyb.

Zoom out and the cumulative tally is staggering: DLA Piper’s January 2026 survey put total GDPR fines since 2018 at roughly €7.1 billion, with about €1.2 billion levied in 2025 alone.^[15] Yet for firms whose advertising businesses are measured in the tens of billions, even a record nine-figure fine is a fraction of a single quarter’s ad revenue. The deeper structural problem — why these penalties function as a license fee rather than a stop sign, and how the “strictly necessary” cookie exemption is abused to skip consent entirely — is the subject of the dedicated follow-up linked above and below.

The Unfortunate Sociological Impact and Influence That Makes Advertising Work

Advertising succeeds by actively shaping desires rather than simply informing choices. It cultivates materialism, ties self-worth to consumption, and fuels both impulse buying and conspicuous display. One of the most cited pieces of evidence is a cross-national study of more than 900,000 citizens across 27 European countries from 1980 to 2011 by Michel, Sovinsky, Proto, and Oswald: the higher a nation’s advertising spend in a given year, the lower its citizens’ reported life satisfaction one to two years later, an effect that survived controls for the business cycle and individual characteristics.^[6] The proposed mechanism is intuitive — advertising inflates aspirations faster than reality can meet them, so the gap between what people have and what they are taught to want widens. This sociological conditioning creates the very demand that justifies ever-larger advertising budgets.

A Contested Picture: Where the Evidence Disagrees

Intellectual honesty requires flagging that the “advertising makes us miserable” thesis is not settled science. A 2023 study in the Journal of International Business Studies by Griffith, Lee, and Yalcinkaya examined per-capita ad spending across 34 countries over nine years against World Happiness Report data and found the opposite relationship: at the country level, higher advertising spending was associated with greater average life satisfaction, not less — though the effect weakened under more lax regulatory regimes.^[7] The authors argue that advertising can convey genuinely useful information about products and services that improve lives, and that institutional context matters enormously.

How can two careful studies reach opposite conclusions? They differ in time window, country set, controls, and the direction of causality they can credibly identify, and they measure subtly different things (year-over-year changes versus broad cross-sectional levels). The reasonable takeaway is not to pick whichever result flatters the argument, but to recognize that aggregate ad spend is a blunt proxy. What plausibly harms wellbeing is not advertising in the abstract but its most intrusive, manipulative, and surveillance-driven forms — the repetitive retargeting, the dark-pattern consent flows, the engineered fear-of-missing-out — which is precisely the slice of the industry this article concentrates on. The peer-reviewed disagreement is a feature of an honest analysis, not a hole in it.

Disposable Revenue, Overpricing, and Media Funding at User Expense

The same conditioning generates the disposable revenue that allows companies to advertise heavily in the first place. When a product’s margins comfortably support massive promotional spending, the core offering is typically overpriced relative to its production, distribution, and genuine value. Advertising simultaneously funds media content while degrading user convenience through interruptions, paywalls, and lowered experience quality. Audiences therefore pay twice: once through their attention and data, and again through reduced wellbeing and inflated product prices. This cycle mirrors the broader trust erosion documented in the preceding articles on media failures and statistical manipulation.

This piece is the third installment of the media-trust series, which traces how the advertising-funded model corrodes the information ecosystem:

Western Media Trust Crisis — how ad and ownership dependency hollows out independent journalism.
Statistics Misuse — how the same incentives bend numbers toward partisan and commercial narratives.
The Cookie Loophole-Loophole — the privacy-and-control deep dive into how consent rules are gamed and why fines change nothing.

Key Takeaways

Advertising intrusion now spans digital media and physical spaces with parallel escalation, leaving 91 percent of consumers reporting higher intrusiveness than in prior years.^[4]
Cookies and related trackers sustain targeted advertising despite regulatory pressure, with research confirming both short-term effectiveness and long-term backlash.
Sociological effects include heightened materialism and impulse consumption; one major 27-country study links higher ad spend to later drops in life satisfaction,^[6] though a competing 34-country study finds the opposite, so the wellbeing question remains genuinely contested.^[7]
Regulators levy record fines — €325M against Google and €150M against Shein in 2025 alone, atop a €7.1B GDPR total — yet they read as a cost of doing business, not a deterrent.^[13]^[15]
Media outlets remain tethered to ad revenue, prioritizing engagement metrics over user experience and thereby accelerating audience distrust.
Substantial advertising budgets serve as a practical indicator of overpricing, as products with genuine merit should not require constant external persuasion.

Conclusion

The advertising landscape exposes a fundamental imbalance. Companies generate enough surplus revenue to bombard consumers across every channel and environment, while users must invest disproportionate time and technical effort simply to reclaim basic attention and privacy. Cookies and data practices amplify the intrusion. Sociological conditioning ensures the cycle self-perpetuates. Media dependency on these dollars further subsidizes content at the direct expense of convenience and trust. Reducing reliance on intrusive monetization in favor of direct value exchange would restore balance and compel products to compete on merit rather than marketing volume.

Sources

Clutch — Ad Fatigue is Real: Why Advertising Strategies Are Failing (91% find ads more intrusive; 93% skip or block ads).
WARC / GroupM, via Marketing Dive — Global ad spend to top $1 trillion in 2024 (WARC ~$1.08T; digital ~73% share by 2025; pure-play internet platforms ~$741B / 68.8% of market). See also eMarketer — Global ad revenues hit $1 trillion milestone (GroupM, $1.04T, +9.5%).
Advertising Week — Brands Must Face Up to the Truth of Ad Fatigue.
HubSpot ad-fatigue research, compiled by Tipsonblogging — 14 Ad Fatigue Statistics (incl. 79% feel tracked by retargeted ads, from a HubSpot survey of 1,055 U.S. browsers).
Google, The Privacy Sandbox — A new path for Privacy Sandbox on the web (Apr 22, 2025 — no consent prompt; third-party cookies retained). Reported by OneTrust.
Michel, Sovinsky, Proto & Oswald — Advertising as a Major Source of Human Dissatisfaction: Cross-National Evidence on One Million Europeans (CEPR DP13532, 2019).
Griffith, Lee & Yalcinkaya — Understanding the relationship between advertising spending and happiness at the country level, Journal of International Business Studies 54(1), 2023, pp. 128–150 (finds a positive country-level correlation — the contrasting result).
Blockthrough — How Bad Ad Experiences Affect UX and Revenue for Publishers (56% of consumers leave a site over bad ads; publishers lose 10–40% of revenue to ad blocking).
Pew Research Center — How Americans View Data Privacy (2023; 72% feel tracked, 81% say risks outweigh benefits, 67% turn off cookies/tracking).
AdGuard — uBlock Origin is forever disabled in Chrome (Manifest V2 → V3, webRequest replaced by declarativeNetRequest).
Amazon — An update on Prime Video (limited ads by default from Jan 29, 2024; ad-free for an extra fee).
São Paulo's Lei Cidade Limpa (Clean City Law, 2007) — overview and outdoor-advertising ban.
CNIL — Cookies and advertisements inserted between emails: GOOGLE fined €325 million (Sept 1, 2025).
CNIL — Cookies placed without consent: SHEIN fined €150 million (Sept 1, 2025).
DLA Piper — GDPR Fines and Data Breach Survey: January 2026 (cumulative €7.1B since 2018; ~€1.2B in 2025).

Moodradar, Real-Time Twitch Chat Mood Analyzer

2026-04-03T00:00:00+00:00

What is MoodRadar

MoodRadar is an experimental, single-file HTML application that turns high-volume Twitch chat into clear, real-time visual insights. Instead of struggling to read thousands of scrolling messages per minute, it instantly shows the overall emotional pulse and consensus of the chat across 11 distinct mood categories.

It lives alongside Ticked inside the github.com/Ranzlappen/ticked repository as a companion tool — no separate repo, no install, no accounts.

How It Works

Enter any Twitch channel name and hit connect. MoodRadar opens a WebSocket connection directly to Twitch’s IRC-over-WebSocket endpoint^[4] as an anonymous read-only listener — no OAuth token needed, no Twitch API key required. Every PRIVMSG (chat message) is received, parsed, and fed through a client-side keyword-and-pattern based sentiment classifier that maps it to one or more of 11 mood labels.

All of this happens in your browser. No proxy, no backend, no data ever leaves the page.

Architecture & Technical Design

MoodRadar is a zero-dependency, single HTML file — the same architectural philosophy as Ticked. The full implementation is self-contained in moodradar.html^[1]:

Transport — Twitch’s anonymous IRC over WebSocket (wss://irc-ws.chat.twitch.tv:443^[4]). The client sends a NICK/PASS of the form justinfan<random> (Twitch’s convention for anonymous read-only connections) and issues a JOIN #<channel> command. No OAuth, no Twitch Developer credentials required.
Message ingestion — A ring-buffer / queue absorbs burst traffic. The dashboard metric panel shows queue depth, dropped messages (when the classifier falls behind), and message rate (msg/s) in real time.
Sentiment classifier — A lightweight, in-browser keyword and emoji pattern matcher that maps each chat message to one of 11 emotions: Hype, Funny, Love, Toxic, Sad, Calm, Angry, Cringe, Wholesome, Confused, Neutral. No external NLP library is loaded — all logic is embedded in the file.
Visualizations — All charts and panels are rendered with vanilla Canvas/DOM. There is no Chart.js, D3, or other charting dependency. Timelines support both linear and log₁₀ scale for handling the large dynamic range of message volumes common in big streams.
Bot detection — A heuristic layer flags likely bot messages (repetitive patterns, known bot name prefixes) and surfaces bot activity as a separate dashboard metric rather than counting bot spam towards the mood scores.

Core Features

Mood Distribution — Real-time breakdown across 11 emotions: Hype, Funny, Love, Toxic, Sad, Calm, Angry, Cringe, Wholesome, Confused, Neutral.
Consensus Bubbles — Bubble size shows frequency; bubble color reflects the dominant mood for that cluster of messages.
Keyword Web — Top terms and phrases currently trending in chat, updated continuously.
Approval Meter & Dissent — Instant gauge of positive vs. negative sentiment ratio.
Mood Timelines — Linear and log-scale views of how the chat mood evolves over time.
Live Feed & Standout Messages — Adjustable live message view with message highlights for unusual or high-signal posts.
Dashboard Metrics — Total messages, rate (msg/s), queue depth, dropped count, bot activity percentage, and unique user count.
Customizable Settings — Max timeline points, update interval, label sizes, and quick preset configurations for different stream sizes.

MoodRadar dashboard: mood distribution, consensus bubbles, and timelines

Approval meter, keyword web, and standout messages in action

Dashboard Panels at a Glance

Panel	What it shows
Mood Distribution	Live bar/pie breakdown across all 11 mood labels
Consensus Bubbles	Clustered bubbles: size = frequency, color = dominant mood
Keyword Web	Real-time top n-grams and phrases trending in chat
Approval Meter	Positive/negative ratio gauge with dissent indicator
Mood Timeline (linear)	Time-series line chart of mood evolution
Mood Timeline (log₁₀)	Same data on a logarithmic scale — useful for large volume swings
Live Feed	Scrolling message feed with mood-colour highlights
Standout Messages	High-signal messages singled out by the classifier
Metrics Bar	msg/s, queue, dropped, bots %, unique users, total messages

High-Throughput Use Cases

MoodRadar was built specifically for high-throughput streams where chat volume makes it impossible to keep up manually. In large gaming broadcasts, major announcements, esports events, or viral moments, messages can arrive at hundreds or even thousands per minute — far beyond any human reader’s capacity.

The tool captures the general chat demeanor instantly — letting streamers, moderators, and viewers know whether the room is hyped, laughing, getting toxic, feeling wholesome, or confused — without reading every line.

Practical scenarios include:

Monitoring audience reaction during boss fights, giveaways, or key story moments in a gaming stream.
Helping moderators detect rising negativity or toxic cluster-spikes before they escalate.
Giving content creators real-time feedback on audience tone during live segments.
Researching collective behaviour in fast-moving communities for academic or journalistic purposes.

Settings & Configuration

MoodRadar’s settings panel (accessible from the dashboard) exposes several tuneable parameters for adapting it to different stream sizes:

Max timeline points — Controls how many time-steps are retained in the mood timeline charts. Increase for long sessions; reduce on slower machines.
Update interval — How frequently (in milliseconds) the visualizations are redrawn. A longer interval reduces CPU load on very high-volume streams.
Label sizes — Adjust the keyword web and consensus bubble font sizes for readability on different display sizes.
Quick presets — One-click configuration bundles tuned for small (< 100 msg/s), medium, and large (> 1 000 msg/s) streams.

No persistent configuration is saved between sessions — settings reset when you reload the page. Twitch channel connection is also session-only.

Live Demo & Video

Try the current version instantly at ticked.ranzlappen.com/moodradar.html — just type a Twitch channel name and click Connect.

Here is a short screencap demonstration of MoodRadar in action on a live Twitch stream:

Privacy Notes

MoodRadar is a read-only, anonymous listener. It does not write to Twitch chat, does not authenticate on your behalf, and does not store message history anywhere — all data lives only in the page’s JavaScript memory for the duration of the session. Closing or reloading the tab clears everything.

The anonymous justinfan connection method is officially documented by Twitch^[4] and is the standard approach for read-only IRC clients. It does not require a Twitch account or any credentials from the user.

Early Development Status

MoodRadar is still in an early experimental stage. Core functionality works reliably for moderate-to-high chat volumes, but occasional bugs, performance variations on very high-throughput streams, or incomplete features may appear. It is under active development.

Known limitations at this stage:

The sentiment classifier is keyword and pattern based — it can misread sarcasm, stream-specific emote meaning, or heavily emote-only messages.
Very high-throughput streams (> 2 000 msg/s during peak moments) may produce visible lag in timeline redraws on lower-powered devices.
Settings do not persist between sessions.

Key Takeaways

Real-time client-side analysis of live Twitch chat sentiment and consensus — no accounts, no servers, no API keys required.
Connects via Twitch’s standard anonymous IRC-over-WebSocket protocol^[4] — no OAuth needed.
Multiple intuitive visualizations across 11 mood labels, designed for high-volume, fast-moving chats.
Zero-dependency single HTML file — the same privacy-first, lightweight architecture as Ticked.
Early-stage experimental tool with strong potential for streamers, moderators, and community researchers.

Conclusion

MoodRadar delivers an immediate, visual understanding of Twitch chat mood when traditional reading becomes impossible. For streamers dealing with high-throughput environments or viewers who want to feel the room’s pulse without drowning in messages, it offers a lightweight, privacy-first solution.

As an early-stage project it already provides usable value, and continued development will only make it sharper. Test it on your favourite high-energy stream and see the chat’s true demeanour at a glance.

More project showcases: Ticked · Discord Music Bot · Flipper Zero Framework · HardwareDash · Synth Piano · tools.ranzlappen.com

Sources

Statistics Misuse How Media and Politics Skew Data to Deceive

2026-04-03T00:00:00+00:00

Introduction

Related in this series (media-trust): 1. Western Media Trust Crisis: Independent Journalism & Open AI Rise · 2. Statistics Misuse (this article) · 3. The Atrocious Intrusive Landscape of Advertising

Statistics should inform public debate. Instead, media outlets and politicians frequently exploit them to advance agendas.^[1] Confusion over basic measures — such as the difference between mean, median, and mode — creates openings for deception.^[2] Selective reporting, omitted context, and visual tricks turn neutral numbers into persuasive weapons. This article examines proven techniques, real-world examples, and practical ways to spot manipulation without favoring any political side.

Common Techniques of Statistical Manipulation

Several recurring methods distort data while remaining technically accurate.^[3] Cherry-picking selects favorable subsets while ignoring contradictory evidence. Changing the base period or comparison group alters apparent trends. Loaded polling questions or small, unrepresentative samples produce misleading results. Omitting key context — such as sample size, margins of error, or alternative explanations — leaves audiences with incomplete pictures.

These tactics appear across outlets and administrations. They exploit the public’s limited statistical literacy without fabricating numbers outright.

Selection Bias: When the Sample Itself Is the Deception

Selection bias occurs when the method of collecting data systematically favors certain outcomes or groups, making the sample unrepresentative of the larger population. The numbers may be accurate for the group that was actually measured, yet they are presented as if they describe everyone.

Media and politicians exploit this constantly.^[2] Online polls suffer from self-selection bias — only people motivated enough to click participate, often those with strong opinions. Telephone surveys may over-sample landline owners or older demographics. “Man-on-the-street” interviews or social-media comment sections capture only the loudest voices. Crime or health studies that rely on volunteers attract people who are more engaged than average.

The result is a chart or headline that looks authoritative but rests on a skewed foundation. A poll showing “80 % support” may actually reflect only the 12 % of the population that bothered to answer. Always ask: Who was included? Who was left out? Would the results hold for a truly random, representative sample?

Mean vs. Median: A Favorite Trick in Economic Reporting

Income and wealth statistics offer the clearest illustration. The mean (arithmetic average) sums all values and divides by the count; it is highly sensitive to extreme outliers. The median is the middle value in an ordered list and resists skew. In highly unequal distributions, the mean can dramatically exceed the median.

Media reports on “average income” or “average wage growth” often cite the mean, making conditions appear better for typical households than they are.^[5] Politicians similarly highlight whichever figure supports their narrative on inequality or economic success. The mode — the most frequent value — rarely appears in such debates because it adds little drama.

The gap is not hypothetical. The Census Bureau reported median U.S. household income of $83,730 in 2024, while the mean sits substantially higher because top earners pull the average up; the Gini index of 0.49 — near its highest level in records going back to 1967 — quantifies exactly how skewed the distribution is.^[11] When a headline announces that “average income rose,” it is usually the mean that moved, and the mean can climb in a year when the typical household — the one at the median — saw no statistically significant change at all. The honest question to ask of any “average” is: which average, and how wide is the gap to the median?

Correlation, Causation, and the Confounded Headline

Perhaps the single most abused inference in popular reporting is the leap from “two things move together” to “one caused the other.” Correlation is a measurement; causation is a claim — and the gap between them is where most pseudo-scientific headlines live.

The classic teaching example is ice-cream sales and drowning deaths, which rise and fall together across the year. Neither causes the other; a hidden third variable — summer heat — drives both. That hidden variable is called a confounder, and the entire discipline of statistics exists in large part to detect and adjust for it. Reporting that omits the confounder can make almost any spurious pairing look like a discovery: countries that drink more coffee live longer (wealth confounds), neighborhoods with more bookstores have higher test scores (income confounds), regions with more storks have more babies (population size confounds).

The tell is usually linguistic. Watch for verbs that quietly upgrade a correlation into a cause — “linked to,” “associated with,” and “tied to” are honest hedges, while “causes,” “drives,” and “leads to” are claims that demand a controlled study or a plausible mechanism behind them. A responsible chart of two correlated lines should say what was held constant; a manipulative one simply lets the reader’s pattern-matching brain supply the causal arrow for free.

Survivorship Bias: The Data That Never Shows Up

Survivorship bias is selection bias’s quieter cousin: it distorts conclusions not by who is over-counted but by who is missing entirely from the dataset because they did not “survive” to be measured.

The canonical case comes from World War II. Statistician Abraham Wald was asked where to add armor to bombers, given a chart of bullet-hole density on the planes that returned. The intuitive answer — reinforce where the holes cluster — is exactly backwards. The returning planes are the survivors; the holes show where a bomber can be hit and still fly home. The armor belongs where the returning planes show no damage, because planes hit there never came back to be counted.

The modern equivalents are everywhere. “Successful founders dropped out of college” ignores the far larger population of dropouts whose startups failed and who never make the magazine profile. “This supplement works — look at all these glowing reviews” ignores everyone who tried it, saw nothing, and quietly stopped. “Old buildings were built to last” forgets that the flimsy old buildings already fell down. Whenever a dataset is assembled from the winners, the losers’ absence is itself a data point — and a deeply misleading one when ignored.

Classic and Recent Case Studies

Darrell Huff’s 1954 book How to Lie with Statistics catalogued many enduring tricks that remain relevant.^[9] One modern example involved congressional testimony using a graph of Planned Parenthood funding versus cancer screenings that reversed the time axis to imply causation where none existed. Fact-checkers rated the presentation “Pants on Fire” false.^[4]

Economic and crime data frequently face scrutiny. Claims of record-low unemployment under one administration or dramatic crime drops under another have prompted accusations of selective time frames or data reclassification. Voter-fraud or election-integrity statistics often rely on tiny samples or unverified anecdotes presented as systemic evidence. Each side accuses the other; the pattern persists regardless of who holds power.

The Role of Visuals and Graphs

Graphs amplify deception when y-axes are truncated or do not start at zero, exaggerating small changes.^[1] Time periods are cherry-picked to hide reversals. Dual-axis charts compare unrelated scales to manufacture correlations. These visual sleights appear in campaign ads, cable news segments, and official briefings alike.

The Continuity Illusion: Journalists’ Delirious Love of the Connecting Line

One of the most seductive (and deceptive) tricks in modern data visualization is the humble line chart—especially when applied to discrete, annual, or categorical data. Journalists and YouTubers are absolutely delirious about them. A glowing, continuous line gliding across the screen creates instant drama: rising crime waves, plummeting safety, economic booms and busts. It feels like a story unfolding in real time.

But here’s the problem: a line chart strongly implies that the space between the data points is meaningful and continuous. It suggests smooth, gradual change even when none exists.

Take a recent YouTube video using a line chart of U.S. motor vehicle deaths by year (1999–2023).^[8] The x-axis shows sparse year labels, and a bright white line connects the annual totals with dramatic peaks and valleys. Viewers see a “story” of steady decline, then a sudden crash and explosive recovery. In reality, each data point is a complete yearly total. There is no “mid-2007” death count, no linear slide from December 31 to January 1. The line fabricates continuity where the data is discrete. The same information would be far more honest as a bar chart (each year stands alone) or a step chart (the level stays flat for the full year, then jumps).

Always ask: Is the x-axis truly continuous and densely sampled? Or are we being sold a smooth story between unrelated yearly dots?

The Truncated or Non-Zero Baseline Deception

Even when the right chart type is chosen, the scale can still lie. Starting the y-axis at an arbitrary number (e.g., 40,000 instead of zero) makes modest 5–10 % changes look like explosive 50 % spikes. This is especially common in crime, unemployment, and economic charts on both sides of the political aisle. The numbers themselves remain accurate, but the visual impact is massively distorted.

Choosing the Wrong Chart Type

Beyond line charts, journalists frequently misuse pie charts with too many slices, 3D effects that distort proportions, or area charts where both height and width grow (doubling the perceived change). These choices prioritize drama over clarity and turn neutral data into persuasive theater.

Cherry-Picked Time Windows

A chart may show only the last five years to claim “record crime under X administration” while conveniently omitting the previous decade’s context. The data points are real, but the selected window hides the bigger picture. Always check: What happened before and after the highlighted period?

Chart Clutter and Information Overload

Too many lines, rainbow color palettes, tiny fonts, or overlapping series make a graph nearly impossible to read. Viewers quickly give up and accept the presenter’s spoken narrative. Clutter is often unintentional, but the effect is the same: the audience cannot verify the claim for themselves.

Ignoring Uncertainty: Missing Error Bars and Confidence Intervals

Polls, surveys, and small-sample studies almost never display margins of error or confidence intervals.^[6] A 3 % difference in a poll with a ±4 % margin looks decisive on screen but is statistically meaningless. Without visual indicators of uncertainty, noisy or preliminary data is presented as rock-solid fact.

The Dark Figure: Ignoring the Dunkelziffer (Unreported Cases)

One of the most overlooked deceptions is pretending official statistics capture reality in full. The German term Dunkelziffer (literally “dark figure”) describes the vast number of crimes, incidents, or events that go unreported or unrecorded. The U.S. Bureau of Justice Statistics’ National Crime Victimization Survey — which interviews households directly rather than counting police reports — found that only about 45 % of violent victimizations were reported to police in 2023, and the share is lower still for property crime.^[7] Charts of “official crime rates” therefore show only the visible tip of the iceberg.

Media outlets on every side routinely cite FBI or police statistics as definitive proof that “crime is down” or “crime is exploding”—without ever mentioning the hidden portion. When reporting rates change (due to distrust, fear, or policy shifts), the official numbers can move dramatically even if actual crime stays stable. Honest reporting would acknowledge this uncertainty instead of treating the charted line as the complete story.

Impacts on Public Opinion and Democracy

Repeated exposure to skewed statistics erodes trust in institutions and data itself.^[6] Voters make decisions based on distorted pictures of inequality, crime, economic health, or policy effectiveness. Policy debates become polarized around competing narratives rather than shared facts. Over time, this weakens democratic accountability.

A Reader's Self-Defense Checklist

Spotting statistical deception does not require an advanced degree — just a short list of questions asked reflexively before a number changes your mind. The UK Parliament’s guidance on inappropriate use of statistics distils much of this into a single principle: always trace a figure back to its primary source and original context.^[3] Practical checks:

Which average? If a story says “average,” find out whether it means the mean or the median, and how far apart they are. In any skewed distribution — income, house prices, wait times — the choice is the message.
Compared to what, and since when? A percentage with no baseline and no time window is a rhetorical device, not a measurement. Ask what the figure was before the highlighted period and what it did after.
Where is the zero? Glance at the y-axis. If it does not start at zero (and the quantity is one where zero is meaningful), mentally rescale before reacting to the slope.
Who was counted — and who wasn’t? Probe the sample for selection and survivorship bias. A poll of volunteers, app users, or returning customers describes only that group, never the whole.
Correlation or causation? Note the verb. “Linked to” is a hedge; “causes” is a claim that needs a mechanism or a controlled study behind it.
Where is the uncertainty? A result with no margin of error, confidence interval, or sample size is presenting noise as fact. A 2-point lead inside a ±4-point margin is a tie.
What’s the dark figure? For anything counted by an institution — crimes, infections, complaints — ask how much never gets reported, and whether the reporting rate itself is what changed.^[7]

None of these checks require recomputing the data. They simply force the claim to show its work — and most manipulative statistics fail the moment they are asked to.

Key Takeaways

Mean, median, and mode measure central tendency differently; confusing them enables selective storytelling, especially in skewed economic data.
Cherry-picking, omitted context, and small samples are the most common manipulation tactics across media and politics.
Truncated graphs and dual-axis charts visually exaggerate trends without falsifying numbers.
Both legacy media and partisan outlets employ these methods; skepticism should be non-partisan.
Critical consumers should always ask: Which measure of “average”? What is the full time frame? What data was excluded?
Visuals can lie through inappropriate chart types, truncated scales, clutter, omitted uncertainty, cherry-picked periods, and by ignoring the Dunkelziffer—always verify the raw data and chart construction behind the pretty picture.
Selection bias hides in the sampling method itself; always check who was actually measured and who was left out.
Survivorship bias is the data that never appears: winners get counted, losers vanish, and the absence is itself a (misread) data point.
Correlation is a measurement, not a cause; watch the verb (“linked to” vs. “causes”) and hunt for the hidden confounder before accepting a causal headline.
A short reflexive checklist — which average, compared to what, where is zero, who was counted, correlation or causation, where is the uncertainty, what is the dark figure — defuses most everyday statistical manipulation.

Conclusion

Statistics remain essential tools for understanding society. When media outlets or politicians misuse them — intentionally or through carelessness — they undermine informed citizenship. By recognizing the difference between mean and median, demanding full context, and scrutinizing visuals, the public can reclaim the power of numbers. Demand transparency from sources. Cross-check claims against primary data. Statistical literacy is no longer optional; it is a civic necessity.

Sources

SAS Blog (2020). Don’t Be Misled: Exploring Statistics in the Media.
StatisticsHowTo. Misleading Statistics Examples in Advertising and The News.
UK Parliament (2023). How to Spot Spin and Inappropriate Use of Statistics.
YIP Institute. The Misuse of Statistics in Politics: Abortion.
Forbes (2017). How To (Spot A) Lie With Economic Statistics.
Brookings Institution (2023). The Cost of Compromising Federal Data.
Bureau of Justice Statistics — National Crime Victimization Survey (NCVS). — Criminal Victimization, 2023: ~45% of violent victimizations reported to police; the survey measures the unreported "dark figure" directly.
National Safety Council (2024). Motor Vehicle Fatality Data.
Darrell Huff (1954). How to Lie with Statistics.
Edward Tufte (2001). The Visual Display of Quantitative Information.
U.S. Census Bureau (2025). Income in the United States: 2024 (P60-286). — Median household income $83,730; Gini index 0.49 (near record high), illustrating the mean–median gap.

Dark Mode for Pros, Light Mode for Everyone The Web's Subtle Status Signal

2026-04-03T00:00:00+00:00

The Default Divide

Related in this series (Privacy & Control): The Cookie Loophole-Loophole — another look at how the small, "neutral" defaults of the modern web quietly steer the people using it.

Most consumer-facing websites — news portals, e-commerce stores, marketing pages, and social platforms — launch with light mode as the default. Dark mode is available only as an optional toggle, usually respecting the browser’s prefers-color-scheme media query.

In contrast, backends, admin panels, developer consoles, internal dashboards, and coding tools overwhelmingly ship with dark mode enabled by default. This split is now common enough to feel like a law of nature — but it is a convention, not a requirement, and conventions carry assumptions worth examining.

It is worth being precise about what’s actually true before we read meaning into it. The headline claim that “dark mode reduces eye strain” turns out to be mostly context-dependent and partly false: for the large share of the population with normal or corrected-to-normal vision, the controlled research generally finds light mode (dark text on a light background) easier and faster to read, not harder.^[3]^[4] So before we get to status and psychology, the design convention rests on a comfort story the evidence only partly supports.

Real-World Examples

Light-first frontends: Amazon, The New York Times, Shopify storefronts, and most SaaS landing pages open in bright, clean light mode.
Dark-first backends: the Vercel dashboard, the Supabase console, many AWS and GCP internal consoles, terminal emulators, and popular admin dashboard templates ship dark by default.
The split inside one product: the most telling cases are tools that wear both faces. A marketing homepage in light mode that leads to a developer dashboard in dark mode is making a statement about who arrives at each door — even though it is literally the same company, the same brand, and often the same user.

The pattern is consistent: tools built for prolonged, focused work tend to go dark, while interfaces built for quick browsing or broad audiences stay light. It is worth noting this is a recent norm. Early GUIs were overwhelmingly light (the “document on paper” metaphor), and the dark IDE only became a cultural default in the 2010s as code editors like those in the VS Code lineage shipped dark themes out of the box. The convention we now treat as obvious is barely a decade old.

The Official Rationale

Designers cite reduced eye strain for long sessions. Developers and analysts often stare at screens for 8–12 hours. Dark backgrounds lower overall screen luminance — a white page on a typical monitor emits on the order of a few hundred cd/m², and dropping most of that to near-black genuinely reduces the total light hitting the eye, which can feel more comfortable in a dim room at night. The assumption is simple: “This user is a pro who will be here a while, so we optimize for endurance.”

Two caveats are worth flagging up front, because the rationale leans on them. First, the blue-light part of the story is weaker than commonly assumed: the strongest evidence for blue-light harm concerns circadian disruption (sleep timing) rather than retinal damage or eye strain, and reducing screen brightness or using night-shift colour temperature addresses that more directly than inverting the colour scheme. Second, “less light = less strain” is only half the picture; legibility depends on contrast polarity, and on that axis the advantage flips the other way (see the next section).

Light mode remains the default for frontends because it tends to maximize readability in typical office or daylight environments — bright surroundings wash out a dark screen — and because it conveys approachability and trust to first-time or casual users. The Nielsen Norman Group’s own user research finds the audience itself is roughly split: about a third keep their devices in dark mode, about a third in light, and the rest switch by context, which is a strong argument against treating either as the universally correct default.^[2]

What the Research Actually Shows

The eye-strain argument is context-dependent, not universal — and on the single most-studied measure, raw legibility, it actually runs against dark mode for most people.

The clearest, most replicated finding in the literature is the positive-polarity advantage: across multiple controlled studies, people read dark text on a light background (positive polarity = light mode) faster and more accurately than light text on a dark background (negative polarity = dark mode). Piepenbrock, Mayr, and Buchner reported medium-to-large effect sizes for both reading speed and accuracy in favour of positive polarity, and a companion study measured smaller pupil diameters and better proofreading performance in light mode.^[3] The Nielsen Norman Group’s review of this evidence concludes plainly that “light mode leads to better performance most of the time” for users with normal or corrected vision.^[1]

That does not make dark mode worthless — it makes its benefits conditional. The table below summarizes where each mode tends to win:

Condition	Light Mode Advantage	Dark Mode Advantage
Bright ambient light	Better readability and faster reading for most users^[3]	Little; bright surroundings wash out the low-luminance screen
Dim / low-light environments	Screen can feel glaring against a dark room	Lower total light output; often more subjectively comfortable
Long reading tasks (normal vision)	Higher accuracy and faster processing^[3]	Sometimes lower perceived workload, but not better measured performance^[1]
Astigmatism (~1 in 3 adults)	Sharper letter edges; avoids the halation "glow"^[5]	Often worse — bright text on dark can shimmer or smear
Older users	Generally lower mental effort in bright rooms	Mixed; cognitive load varies by ambient light and age^[7]
Cloudy ocular media (e.g. cataracts)	Glare from a bright field can scatter and reduce contrast	Reduced light scatter can genuinely help^[1]

The astigmatism point deserves emphasis because it directly contradicts the “dark mode is gentler on the eyes” folklore. Roughly one in three adults has some degree of astigmatism, and for them bright text on a dark background is prone to halation — light bleeding past the edges of each glyph so characters look fuzzy, glowing, or shimmery — which makes dark mode harder to read, not easier.^[5] Where dark mode does have a defensible visual-comfort case is for users with cloudy ocular media such as cataracts, where reducing the overall light field cuts down on scatter.^[1]

Eye-tracking and cognitive-performance studies broadly support this: Sethi and Ziat’s eye-tracking work found that negative polarity (dark mode) raised cognitive load — visible as longer search times and larger pupil diameters — for older adults in bright rooms and younger adults in dim rooms, underscoring that the “best” mode depends jointly on the user and the lighting.^[7] A more recent eye-tracking study on dark versus light themes likewise measured higher user workload under dark themes for the tasks tested.^[4] The honest summary: dark mode shines for low-light comfort and subjective preference during long sessions, and it genuinely helps some impaired-vision users, but for legibility and measured performance among the general, normal-vision population, light mode tends to win. It is not universally superior — and neither is dark.

One more thread ties this to accessibility standards rather than taste. Whatever polarity you choose, the WCAG 2.1 contrast-minimum criterion requires a contrast ratio of at least 4.5:1 for normal text (3:1 for large text).^[6] A common dark-mode mistake is pure white text on pure black, which is technically high-contrast but can intensify halation; design guidance generally recommends slightly off-white text on a dark-grey (not jet-black) surface to keep the ratio compliant while taming the glow.

The Mechanism: Why Polarity Matters

It is worth understanding why light mode tends to read better, because the reason is physiological rather than aesthetic. A brighter overall field (light mode) makes the pupil contract. A smaller pupil reduces spherical aberration and increases depth of field, so the retinal image of the text is sharper — which is exactly what improves legibility and is the mechanism researchers credit for positive polarity’s reading-speed and accuracy gains.^[1]^[3] The same effect explains the astigmatism penalty in dark mode: a larger pupil (in a dark field) lets in more of the eye’s own optical imperfections, amplifying the smearing that halation already causes.^[5]

Two honest counterweights keep this from being a blanket “always use light mode” verdict. First, the performance gap is measured in seconds and percentage points over reading-heavy tasks — for glanceable dashboards full of charts and status lights rather than prose, it largely evaporates, which is part of why dashboards get away with going dark. Second, NN/g notes a speculative long-term consideration: sustained bright-light exposure has been associated with myopia progression, so the short-term legibility win is not automatically a lifelong health win.^[1] The responsible reading of the evidence is “it depends,” not “dark mode is a myth.”

Choosing Defaults Responsibly

If no mode wins universally, the design takeaway is not “pick the right one” but “stop hard-coding a default that encodes an assumption about your user.” A few concrete practices follow directly from the research:

Honour prefers-color-scheme. The operating system already knows the user’s stated preference and time-of-day context. Respecting it ships the right default to roughly two-thirds of people who have an opinion, for free.^[2]
Offer a visible, persistent toggle — not buried in settings — and remember the choice. The research’s central finding is that the population is split, so the only universally correct answer is let them choose.
Design dark mode properly if you ship it: off-white on dark grey, not white on black; keep contrast at or above the WCAG 4.5:1 floor; and avoid thin or light-weight fonts, which suffer most from halation.^[6]
Match the mode to the task, not the audience’s imagined status. Long-form reading leans light; glanceable, chart-heavy, low-light monitoring leans dark. That is a functional decision — and, as the next section argues, it is too often made for non-functional reasons.

The Psychological Status Signal

This technical choice carries a subtle message.

Dark mode has become cultural shorthand for “power user” and “serious work.” It feels modern, focused, exclusive, and sophisticated. Receiving a dark interface can make users feel respected as experts.

Light mode, while more readable and trustworthy in many contexts, can feel mass-market or “basic.” When a frontend forces light mode (or a backend feels unusually bright), some users internalize the friction — slower reading, higher mental effort, or visual discomfort — as personal failure rather than design intent. The interface quietly suggests: “We built this for average users, not pros like you.”

It is not that the site literally calls anyone stupid. It is that the default mode hierarchy creates an unconscious status gradient: dark = capable insider, light = casual outsider. Users notice this on a gut level even if they cannot articulate it.

There is a small irony buried here. The convention sells itself on comfort and expertise, yet the research suggests the “expert” dark dashboard is often the less legible of the two for the majority of eyes reading it.^[1]^[3] The signal, in other words, is doing cultural work that the ergonomics do not back up. That is exactly what makes it a status signal rather than a usability decision: its persistence is explained better by what it communicates than by how well it performs.

This connects to the broader theme of this series. Like a cookie banner whose “Reject all” button is hidden two clicks deep, a hard-coded colour default is a small design choice that quietly encodes a judgment about the person on the other side of the screen — and, like the cookie banner, it works precisely because most people never consciously register it. The remedy is the same in both cases: surface the choice, respect the user’s stated preference, and stop letting a convenient default stand in for consent.

Key Takeaways

Backend dark defaults signal “we expect expert, long-session use”; frontend light defaults prioritize broad accessibility and trust.
The “dark mode reduces eye strain” claim is only partly true: for normal-vision users in typical lighting, light mode (positive polarity) is generally read faster and more accurately.^[1]^[3]
Dark mode’s real wins are narrower than the folklore: low-light comfort, subjective preference, and some impaired-vision cases (e.g. cataracts) — while it can be worse for the ~1 in 3 adults with astigmatism due to halation.^[5]
Cognitive performance is context-dependent — no mode wins universally, and the audience itself is roughly split, which is the strongest argument for honouring prefers-color-scheme and shipping a real toggle.^[2]
Whatever you ship, meet the WCAG 4.5:1 contrast minimum and prefer off-white-on-dark-grey over white-on-black.^[6]
The dark/light split reinforces a subtle expertise hierarchy that the ergonomics do not actually justify; choose defaults consciously rather than following convention.

Conclusion

The web’s dark/light split is not merely a technical or accessibility decision. It is a quiet statement about who the product believes its user to be. The evidence is clear enough to puncture the comfort story the convention tells about itself — light mode is generally the more legible choice for most eyes most of the time — and clear enough to refuse the opposite overcorrection, because dark mode genuinely helps in low light, suits glanceable interfaces, and is the right call for some users’ vision. What it does not justify is being silently imposed as a marker of who belongs.

So the practical conclusion is modest and falls back on respect: detect the user’s stated preference, expose an obvious toggle, design both modes to the same accessibility bar, and let the human decide. As more interfaces ship in 2026, understanding this psychological layer helps designers build with intention — and helps users recognize when an interface is quietly shaping how capable they feel, before they even notice.

Sources

Budiu, R. — Nielsen Norman Group (2020). "Dark Mode vs. Light Mode: Which Is Better?" (positive-polarity advantage for normal vision; pupil/aberration mechanism; cataract and myopia caveats).
Nielsen Norman Group (2023). "Dark Mode: How Users Think About It and Issues to Avoid" (the roughly even split of user preference and context-switching behaviour).
Piepenbrock, C., Mayr, S., & Buchner, A. (2014). "Positive Display Polarity Is Particularly Advantageous for Small Character Sizes," Human Factors; and Piepenbrock et al. (2014), "Smaller pupil size and better proofreading performance with positive than with negative polarity displays," Ergonomics.
An Eye Tracking Study on the Effects of Dark and Light Themes on User Performance and Workload (2025), Proceedings of the 2025 Symposium on Eye Tracking Research and Applications (ETRA).
Smithsonian / Stoney Creek Optometry — overview of "Is Dark Mode Better for Your Eyes?" (astigmatism prevalence and the halation effect that makes dark mode harder to read for many).
W3C Web Accessibility Initiative — "Understanding Success Criterion 1.4.3: Contrast (Minimum)" (the 4.5:1 / 3:1 contrast thresholds).
Sethi, T. & Ziat, M. (2023). "Dark mode vogue: do light-on-dark displays have measurable benefits to users?" Ergonomics, 66(12) (eye-tracking cognitive-load analysis across age and ambient-light conditions).

Ticked: Offline Process & Workflow Tracker

2026-03-31T00:00:00+00:00

What Ticked Does

Ticked gives you two seamless tabs: Log for quick timestamped entries and Processes for multi-stage workflow tracking. Every change auto-saves to your browser’s localStorage^[3]. Your data stays on your device, works completely offline, and never leaves your machine.

At its core, the Log tab lets you press a button or hit Enter to instantly log the current timestamp like a traditional logbook. This simple one-action capture is particularly helpful for real-time time tracking, habit logging, event documentation, or quick personal journaling—eliminating friction so you can record exactly when something happens without extra steps or apps.

Live at ticked.ranzlappen.com — open it and it is ready immediately, no sign-up required.

Core Features

Dual Tabs for Flexibility
Switch instantly between Log (quick notes and custom-timestamped entries) and Processes (full workflow tracking).
Checkpoint & Stage Tracking
Create processes, add dynamic checkpoints with names, due dates, comments, and notifications. Progress updates via a visual horizontal timeline.
Smart Filters & Sorting
For Log: All / Auto-logged / Custom / Edited. For Processes: All / Edited / Overdue. Combine with search, date pickers, and sort by time or name.
Timeline & List Views
Toggle between chronological timeline (with day headers) and classic list. Swipe gestures on mobile integrate well for phones, offering quick delete or actions.
Silent Instant Logging
Type, hit Enter or tap Log—entries save automatically with no buttons or spinners.
Color Palette Customization
Edit your app’s color scheme on the fly; changes persist across sessions.
Multi-Language Support
Interface available in English, Spanish (Español), German (Deutsch), and French (Français).
Full Responsiveness & PWA-Ready
Scales perfectly from phone to desktop. Installable via browser “Add to Home Screen” with service worker support.
Advanced Backup & Export
One-click JSON export, import, Google Drive sync option (with your own client ID), and built-in “Download Offline HTML” for a self-contained backup file.

Architecture & How It Works

Ticked ships as six files, four of which provide the full application logic^[1]:

File	Role
`index.html`	Application shell and markup
`app.js`	All application logic — state, UI, event handling
`styles.css`	UI styling and CSS theme tokens
`i18n.js`	Language dictionaries for the four supported locales
`sw.js`	Service worker — caches assets for offline use
`manifest.json`	PWA metadata — name, icons, `display: standalone`

State persistence is handled entirely by the Web Storage API. All log entries, process definitions, checkpoints, and settings are written to localStorage on every change (no debounce — every keystroke and tap triggers a save). The storage key is ticked_store.

Offline operation works via the service worker caching strategy: all six application files are precached on first load. Subsequent visits — even with no network — serve entirely from the cache. Bumping CACHE_REV in sw.js forces clients to fetch fresh assets on next load, which is the only “release” mechanism for a file served from GitHub Pages.

PWA installation is driven by manifest.json with display: standalone. Visitors on Chrome/Edge (desktop) or any mobile browser get an install prompt. Once installed, Ticked appears as a standalone app with no browser chrome, indistinguishable from a native app.

Google Drive sync is optional and requires the user to supply their own OAuth client ID from Google Cloud Console. No credentials are ever stored server-side — the OAuth flow is entirely client-side via the Google Identity Services library. Drive sync is disabled by default and is only activated from Settings.

There are no build tools, no bundler, no node_modules. Development is as simple as:

# Without service worker (instant, no caching)
open index.html

# With full PWA features (service worker requires a server origin)
python3 -m http.server 8080
# visit http://localhost:8080/

Technical Advantages

Ticked is a single-origin, dependency-free application built with vanilla JavaScript, CSS, and HTML—no frameworks, no build step.

100 % Local & Offline
Data lives in localStorage under the key ticked_store. The included service worker (sw.js) and manifest enable true offline use and PWA installation. Once saved locally, Ticked runs forever without internet.

Privacy First
No accounts, no telemetry, no analytics, no external calls—except for the optional Google Drive sync, which the user explicitly opts into with their own credentials. Your workflows remain completely private by default.

Under 100 KB
The entire application — HTML, CSS, JavaScript, and i18n strings — loads in milliseconds. Service worker caching means repeat loads are instantaneous.

Easy Instant Access
Use it immediately at the live app or save the page as index.html (File → Save As in any browser) for a portable, offline copy. Updates are as simple as replacing the file.

Configuration & Settings

Ticked has no config file — all settings are exposed through the in-app Settings panel and persisted in localStorage alongside your data. The available options are:

Language — Switch between English, Español, Deutsch, and Français at any time. The choice is saved immediately.
Color palette — Edit the app’s color scheme; tokens are stored per-session and persist across reloads.
Google Drive sync — Paste your Google Cloud OAuth client ID to enable optional cloud backup. Can be disconnected at any time from the same panel.
Cache invalidation — If you self-host, bump CACHE_REV in sw.js to push an update to all cached clients.

Potential Use Cases

Freelance project logging—track deliverables stage by stage.
Daily personal workflows—log routines, side projects, or learning checkpoints.
Team hand-off notes—export a clean JSON or offline HTML snapshot.
Offline fieldwork—reliable tracking when connectivity is unavailable.
Minimalist productivity—replace bloated apps with a tool you own.
Logbook-style timestamping—freelance billable-hours logging or daily mood/event journaling.

How to Get Started

Visit ticked.ranzlappen.com and start using it immediately — no install, no account.
For a fully offline portable copy, save the page (File → Save As → index.html) and open it in any browser.
To install as a PWA on mobile, tap your browser’s Share → Add to Home Screen; on desktop, look for the install icon in the address bar.

Development Note: Ticked is still in active development. While the core functionality is stable and ready to use, occasional bugs may appear. Feedback and bug reports via GitHub are welcome.

Important Note on Data Persistence

Ticked stores everything in your browser’s localStorage. Clearing cookies or site data for this domain will delete your entries and processes. Regular backups are strongly recommended — use the built-in Export button to download a .json file anytime, or use Download Offline HTML for a complete self-contained backup that also works without internet.

Also note: localStorage is per-origin and per-browser profile. If you use Ticked on both your phone and your laptop, the data does not sync automatically. Use the JSON export/import or configure Google Drive sync to keep devices in step.

Troubleshooting & Pitfalls

Service worker not updating after a code change?
The PWA caches aggressively. If you self-host, bump CACHE_REV in sw.js and redeploy. In-browser you can force-clear via DevTools → Application → Service Workers → Unregister, then hard-reload.

”Add to Home Screen” prompt not appearing?
This requires the site to be served over HTTPS (or localhost). Opening index.html directly as a file:// URL suppresses the install prompt and disables the service worker.

Google Drive sync not connecting?
You need a Google Cloud project with the Drive API enabled and an OAuth client ID scoped for your origin. The client ID you paste must exactly match the domain you’re running Ticked on.

Data appears to be gone after clearing browser history?
Most browsers tie localStorage to site data. “Clear browsing data” in most browsers includes site data by default. Always export a backup before clearing.

Key Takeaways

Single-origin HTML app—zero dependencies, zero build step, instant load, fully offline.
Dual Log + Processes tabs with checkpoint timelines and smart filters (All / Edited / Overdue).
Silent auto-save to localStorage with PWA support for an app-like experience on any device.
Built-in backup: JSON export/import, optional Google Drive sync, and offline HTML download.
Multi-language (EN, ES, DE, FR) with fully responsive UI, swipe gestures, and color customization.
100 % private—no accounts, no servers, no telemetry; data never leaves your device unless you choose Drive sync.

Conclusion

Ticked delivers powerful workflow tracking in the lightest possible package. Whether you open it online for immediate use or save it locally for permanent offline access, you get instant logging, checkpoint progress, smart organisation, and total data ownership. If you value speed, simplicity, and control over your own information, Ticked is ready the moment you open the page.

Star or fork the project on GitHub: github.com/Ranzlappen/ticked.

More project showcases: MoodRadar · Discord Music Bot · Flipper Zero Framework · HardwareDash · Pageside · tools.ranzlappen.com

Sources

Western Media Trust Crisis: Independent Journalism & Open AI Rise

2026-03-31T00:00:00+00:00

Western Media Trust Crisis: Independent Journalism & Open AI Rise

Related in this series (media-trust): 1. Western Media Trust Crisis (this article) · 2. Statistics Misuse: How Media and Politics Skew Data to Deceive · 3. The Atrocious Intrusive Landscape of Advertising

This analysis focuses exclusively on media ecosystems in Western democracies — the United States and Europe — where corporate and public-funded outlets operate in relatively free but commercially and politically pressured environments. These systems differ markedly from state-controlled or suppressed media in non-Western contexts. Public trust in legacy Western media has eroded sharply. The Reuters Institute’s Digital News Report 2025 shows overall trust stable at 40% globally, but with notable Western divergence: the US sits at just 30%, Germany at 45% (down roughly 15 percentage points since the 2015 peak), and the UK at 35% — a particularly steep 16-point fall since 2015.^[1] Concern over distinguishing truth from falsehood online reaches 73% in the US versus around 46% across much of Western Europe.^[1] These figures reflect shared structural failures — paywalls, advertising dependency, user-data exploitation, ideological framing, statistical manipulation, fluff, and suppressed feedback — driving audiences toward independents while highlighting the case for minimally restricted AI.

It is worth stating the qualifications plainly. Trust is not collapsing uniformly: Finland (still the highest in the survey at around 67%) and several Nordic markets remain far more trusting than the Anglophone world, and “trust in the news I use myself” runs well above headline trust almost everywhere (57% in Germany, for instance).^[1] The crisis is therefore best understood as a crisis of institutional trust — confidence in the press as a category — rather than a wholesale rejection of journalism. That distinction matters, because it is precisely the gap between “I distrust the media” and “I trust this specific writer I pay for” that independent journalism has rushed to fill.

The American picture is the starkest. Pew Research Center’s longitudinal tracking found that just 56% of US adults expressed at least some trust in information from national news organizations in late 2025 — down 11 percentage points in a single year and a 20-point fall since the question debuted in 2016.^[13] Crucially, the decline is bipartisan in direction even where it is asymmetric in magnitude: Democratic trust dropped to 69% (its lowest on record) while Republican trust sat at 44%, and both parties now place equal trust (37% each) in social media as an information source.^[13] Local news remains the relative bright spot at 70%, a reminder that proximity and accountability — not the act of reporting itself — are what audiences reward.

US vs Europe Data Snapshot

Country/Region	Trust in News (%)	Change Since 2015	Fake News Concern (%)
United States	30	Stable (low)	73
Germany	45	-15pp	~46 (Western Europe)
United Kingdom	35	-16pp	~46 (Western Europe)
Western Europe	40–50 (avg)	Declining	46

Source: Reuters Institute Digital News Report 2025^[1]

Corporate and Public Media's Structural and Editorial Failures Across the West

Revenue pressures dominate both corporate and publicly funded models. In the US, the subscription model leaves the majority of adults outside any paywall — only a minority pay for online news at all, and of those who do, most pay for a single outlet, leaving the rest of the market squeezed for ad revenue.^[1] Europe shows parallel stagnation despite public funding for broadcasters. Advertising dependency fuels clickbait on both sides of the Atlantic: the incentive is the click, not the clarification, and the headline is optimised accordingly. User-data exploitation persists via trackers, often with opaque consent flows even in the GDPR-era EU, where “reject all” is frequently buried two clicks deeper than “accept all.”

Publicly or partially government-funded outlets face additional, distinct problems. In Germany, ARD and ZDF operate under compulsory household financing via the Rundfunkbeitrag (broadcasting fee, currently €18.36/month), which every household must pay regardless of whether anyone in it watches or listens.^[2] Critics highlight inflated staff and overhead — the combined ARD/ZDF system employs tens of thousands and carries a famously generous pension burden — with bureaucracy mirroring public-sector bloat, fuelling recurring calls for leaner operations.^[3] The fee debate has become a constitutional saga: the KEF commission recommended raising the fee to €18.64 from 2027, states declined to enact the earlier increase, ARD and ZDF filed a constitutional complaint, and the Federal Constitutional Court took up the matter in 2026 — all against a backdrop of accusations of political-proximity bias and limited transparency over how the money is spent.^[2] Similar tensions appear across Europe’s public broadcasters, from the BBC licence-fee debate in the UK to France’s abolition of the redevance audiovisuelle, where compulsory or state-budget financing weakens direct accountability to the audience it is meant to serve.

It would be unfair to flatten the picture entirely. Public broadcasters still produce a great deal of the West’s most expensive, least commercially viable journalism — long-form investigations, foreign bureaus, regional coverage that no ad-funded startup will replicate. The critique is not that the model produces nothing of value; it is that compulsory financing severs the feedback loop between the audience’s approval and the institution’s survival, so quality and bloat can coexist indefinitely with no market signal to correct either.

Editorial flaws are more consistent. Outlets embed ideological framing — climate, social policy, economics — ahead of raw evidence, and the framing is rarely labelled as such. Reporting often lacks conciseness, padded with opinion presented as context. Statistics are selectively presented (the sibling article in this series, Statistics Misuse, is devoted entirely to that mechanism). And transparency falters at exactly the moments it matters most: corrections are buried deep or appended silently, and audience criticism faces algorithmic demotion or moderated-away comment sections.

Legacy TV's Structural Limitations in Western Media

Traditional broadcast TV exacerbates many of these failures, particularly in public-funded systems. Unlike digital platforms, TV remains largely one-way: viewers cannot provide live feedback, comment in real time, or hold producers accountable during broadcasts. This lack of interactivity contrasts sharply with independent newsletters or podcasts, where audience input is immediate and public. In Germany and across Europe, linear TV channels (many operated by ARD/ZDF) face declining audiences as viewers shift online, yet reforms to close select channels (e.g., ARD alpha, tagesschau24 by end-2026) come slowly.^[4] The result is reduced responsiveness and a further disconnect from digital-native audiences.

The Self-Reinforcing Link to Educational Decline in Western Societies

Corporate and public media flaws fuel and are fueled by weakening media literacy. The News Literacy Project’s November 2025 US teen report found 84% hold negative views (“biased,” “boring,” or “bad”), with 45% believing journalists harm democracy and 69% perceiving intentional bias.^[5] Reuters 2025 notes similar avoidance trends across Europe, where social media fills gaps left by declining traditional engagement. EU media literacy initiatives exist but remain limited, with educators allocating minimal hours amid competing demands.^[6] This cycle reduces demand for critical-thinking education while leaving audiences vulnerable to spin evident in both US partisan divides and European public-broadcaster skepticism.

Independent Journalism's Rapid Ascent and Accountability Model

Independent creators fill the vacuum. Substack surpassed 5 million paid subscriptions by early 2025, with growth accelerating in both US and European markets through direct reader funding over ads.^[7] A Change Research poll (December 2025) found 34% of Americans trust independent/online journalists most nearly triple national outlets mirroring rising European reliance on newsletters and podcasts.^[8] These models enforce accountability: readers pay for value, feedback is public, bias is transparent and market-tested. Conciseness, source transparency, and responsiveness replace institutional opacity.

What Actually Rebuilds Trust: Three Mechanisms

It is easy to diagnose decline and harder to say what the successful independents actually do differently. Three mechanisms recur across the outlets that have won durable reader loyalty.

1. The feedback loop is reconnected. A reader-funded writer survives only if subscribers keep paying month to month. That single fact reattaches the survival of the publication to the satisfaction of its audience — the loop that compulsory financing severs. When a Substack writer publishes a weak piece, churn rises within the billing cycle; when a public broadcaster does, the Rundfunkbeitrag arrives regardless. The discipline is not virtue, it is plumbing.

2. Bias is disclosed rather than denied. Legacy outlets typically claim a view from nowhere and then smuggle framing in through word choice, story selection, and which experts get quoted. Independents tend to wear their priors openly — and a declared slant is far easier for a reader to discount than a denied one. Transparency about standpoint, paradoxically, reads as more honest than the institutional pose of neutrality that audiences have learned to distrust.

3. Corrections are visible and fast. The most trusted independents timestamp edits, publish errata above the fold, and engage critics in the comments rather than moderating them away. Compare this to the legacy habit of silent edits and buried corrections, which News Literacy Project surveys identify as a top driver of the “intentional bias” perception among younger readers.^[5]

These mechanisms also explain the Pew finding that local news outperforms national: locality forces the same accountability that reader-funding manufactures. A regional editor meets the audience at the grocery store; a national anchor does not.^[13]

A Necessary Counterpoint: Where Independents Fail

Honesty requires stating the failure modes too. Reader-funded journalism is not a panacea, and pretending otherwise would repeat the very credulity this series criticises.

The most obvious risk is the echo-chamber incentive. A writer paid directly by an audience has a financial reason to tell that audience what it wants to hear; the same feedback loop that rewards responsiveness can reward flattery. Subscription models can therefore manufacture narrower worlds, not broader ones — the opposite of the shared-fact baseline a democracy needs.

Second, independents rarely fund the expensive, unglamorous work: foreign bureaus, multi-year investigations, courtroom and statehouse coverage that produces no viral moment. Much of that load still falls to the very legacy and public institutions under critique here, which is why “abolish the broadcasters” is a worse answer than “reform their accountability.”

Third, the space is vulnerable to capture and grift. The low barrier to entry that lets a great reporter go independent also lets a confident fabulist build an audience with zero editorial check. Without the institutional friction of an editor and a corrections desk, a charismatic individual can spread a polished falsehood faster than any newsroom. The model rewards trust-building but does not by itself reward trustworthiness — readers must still supply the scrutiny.

The honest conclusion is not “independents good, institutions bad,” but that the accountability architecture matters more than the label. Whatever reconnects output to audience approval — reader funding, locality, transparent corrections — tends to rebuild trust; whatever severs it tends to erode trust.

AI Development with Minimal Guardrails: The Essential Counterbalance

Fragmented Western information ecosystems demand AI prioritizing evidence over curated safety. Heavy guardrails in leading models risk echoing legacy media biases. Minimally restricted development pairs naturally with independent journalism.

Recent 2025–2026 studies compare:

ChatGPT (OpenAI) and Claude (Anthropic) use extensive filters, showing consistent left-leaning tendencies on social/economic issues per IEEE Access 2025 and Anthropic’s November 2025 research.^[9]^[10] Refusals limit analysis.
Gemini (Google) adopts centrist framing but retains corporate-aligned guardrails, with high refusal rates per Brookings (October 2025).^[11]
Grok (xAI) employs lighter restrictions. Evaluations rank it among the lowest in detectable bias and highest in responsiveness, with minimal refusals.^[12] It surfaces evidence-based views without ideological defaults.

Minimal guardrails block illegal content but avoid external shaping distorting Western media narratives. In an era of filtered reporting, such AI delivers unvarnished data across US and European perspectives.

Key Takeaways

Western media trust is critically low: US 30%, Germany 45% (-15pp), UK 35% (-16pp) per Reuters 2025, driven by paywalls, data exploitation, compulsory fees, staff bloat, and opacity.
Public broadcasters add unique issues: Germany’s ARD/ZDF compulsory Rundfunkbeitrag and large staffing levels fuel inefficiency and bias debates.
Legacy TV’s one-way nature limits live feedback, widening the gap with digital independents.
These failures correlate with teen media illiteracy (84% negative US views) and parallel European trends.
Independent journalism leads trust via direct accountability; minimally restricted AI like Grok supports unbiased inquiry.
Transparent, feedback-driven systems in journalism and AI are essential for Western democratic discourse.

Conclusion

Western corporate and public media’s monetization-over-mission and forced-financing models have accelerated decline on both sides of the Atlantic, degrading critical thinking in education. Independent journalism provides a reader-funded corrective, while minimally guarded AI offers technological reinforcement. Prioritizing evidence, transparency, and minimal external influence is foundational for informed citizenship in 2026 and beyond.