Resurrecting a 1990s video mixer with modern web technology sounds like an engineer's whim, but it is exactly the kind of challenge that reveals how well-designed software can honor hardware without pretending to copy it. The Panasonic WJ-MX50 was a desktop unit for A/B editing on S-VHS, with two buses, 287 wipe patterns, chroma key, eight event memories, and a joystick that techno club VJs turned into a visual musical instrument. Now, thanks to WebGPU, TypeScript, and an obsession with original behavior, that instrument is reborn in the browser. And along the way, it leaves lessons that every custom software development company should hear.
The web-mx-50 project is not a typical emulator. It does not try to replicate every pixel of the 1992 NTSC circuit, because modern video formats no longer have interlacing or chroma subsampling. Instead, it reproduces the device's observable behavior: which LED blinks when you press a button, how the joystick behaves when applying the mosaic effect, how many frames a fade takes when you adjust the Auto Take control (0 to 510, in steps of two). That is what turns a mixer into an expressive instrument, and that is exactly what has been brought into the digital world.
The project's architecture is an example of how custom application development should be done when domain fidelity matters. It all starts with the Panasonic user manual, 40 pages that describe with almost surgical precision the panel's state transitions. That manual became the program: no code was written until the 536 Gherkin scenarios (written in natural language) were ready to fail the test if the color order of the matte did not match the original document. This specification-first, code-later discipline is the same we apply at Q2BSTUDIO when tackling process automation, artificial intelligence, or cybersecurity projects: understand the system's behavior before touching a line of code.
The mixer's heart is a single JSON-serializable value representing the complete panel state. Every change goes through a pure reducer, with no classes or observables. This makes event memory trivial: cloning the state and saving it into one of eight slots is a simple structuredClone call. It also simplifies browser persistence, remote control via MIDI or gamepad, and integration with external systems. At its core, it is the same philosophy we follow in our cloud services on AWS and Azure: having a single source of truth prevents data from scattering and state transitions from becoming fragile.
The graphics part runs on WebGPU. The 287 wipe patterns are not a giant list but an algebra: seven families, each with four variants, plus stackable modifiers (compression, slide, multi, pairing, blinds) and a legality table. The wipe shader treats each family as an analytic signed distance field. One shader, one uniform block, seven fields. The decision to render in linear space (sRGB with gamma correction) avoids darkening at wipe edges, a problem the original hardware did not have because its output was analog, but which software must resolve explicitly.
Timing is another interesting chapter. The original MX50 measured fades in video frames, not milliseconds. The current code uses a fixed‑timestep logical clock: an accumulator converts real time into whole frame ticks, and all time‑dependent logic reads only ticks. A 300‑frame fade lasts exactly 300 ticks on both a 60 Hz and a 144 Hz monitor. This is crucial for VJs who need to land a transition right at the start of a musical phrase. It is also an example of how a well‑designed information system should abstract real time to guarantee determinism, something we apply in artificial intelligence and autonomous agent projects where synchronization between events is critical.
One of the project's most original aspects is that it did not try to emulate the frame synchronizer circuit because that problem no longer exists in modern video streams. Instead, it leveraged the side effects that circuit generated: the per‑bus frame stores that enable Still, Strobe, Multi, and Trail modes. Sharing a single framebuffer per bus makes the mutual exclusion rules (Still and Strobe cannot be active simultaneously; Trail rides on Still) fall out naturally. This is an example of how understanding the original hardware constraints facilitates software design.
From the perspective of a company like Q2BSTUDIO, this project illustrates several lessons transferable to any enterprise software development. First: the specification must be executable. The Panasonic manual, transformed into Gherkin scenarios, acts as a continuous regression test. When someone modifies the code and breaks the blinking order of an LED, the test fails. That is exactly what we implement in our Business Intelligence services with Power BI: validating that dashboards faithfully reflect business rules before deployment. Second: a single serializable state architecture simplifies all features that seem complex — event memory, persistence, remote control — and prevents state fragmentation across components. We apply the same architecture in cybersecurity systems where every action must be auditable and reproducible.
The project also touches on artificial intelligence, albeit indirectly. The MX50 panel has eight event memories that can be programmed and then triggered with a single button. That is, in essence, a visual sequence automation system. At Q2BSTUDIO we develop AI agents that make sequential decisions on real‑time data, and the mixer's event logic is a distant cousin of those systems. The ability to map a MIDI controller or gamepad to the same command language as the physical buttons opens the door to alternative user interfaces, something we explore in industrial automation projects.
The current state of the project is a complete, verified prototype with 536 Gherkin scenarios and 208 conventional unit tests. The source code is published on GitHub, and next steps include a web component that allows embedding the mixer in any site, a UI replicating the original panel, and support for multiple tabs and windows. We will also explore using the mixer as a real‑time visual art tool within web pages, combining it with video sources generated by AI or with sensor data.
In short, resurrecting the Panasonic WJ-MX50 with WebGPU is not just a tribute to an iconic piece of hardware. It is a demonstration of how well‑built software — with executable specifications, single‑state architecture, and time abstraction — can capture the essence of a physical instrument and bring it to the web without losing expressiveness. At Q2BSTUDIO we apply that same philosophy every day, whether developing custom applications, deploying cloud infrastructure, securing systems against cyberattacks, or building artificial intelligence agents. Because in the end, what matters is not the technology, but the behavior that technology enables.
