One definition per device
A device is a plain YAML file. The real driver and the simulator are both generated from it, so they can't drift apart.
Open source · Built in the open
The universal audio visual and IoT operating system.
One free platform to design, commission and run every room. The simulator and the real equipment run from the same project, and every difference between the design and the room is explained in plain words.
Showing: the laptop on the display. Every device on the path confirmed.Press a source · slide the volume · press the PDU or the amplifier
Every room gets programmed twice: once on paper, and once on site.
I've spent over twenty years sitting at the junction between humans and technology, trying to help both have less to do on behalf of one another. My focus has always been efficiency: finding ways to do less in order to achieve more.
This is how it normally goes. A programmer designs a room in one headspace, often before any of the equipment arrives, hoping the right equipment turns up and nothing gets substituted. That code is then handed down to a field team, who deal with what is actually real: different hardware, or the right gear that didn't arrive in time. Now there's work to get done, and no complete room to do it in.
AV.OS's simulators change that. A device that isn't there yet can still act as if it's on the network, acknowledging and confirming the right commands, so the team can keep testing the equipment that is. A room doesn't have to be complete to be worked on.
There's a second gap. Everyone seems to think they own the best version of the software, because they know what the client wants. AV.OS takes the opposite view: let the clients help build the software they want. Open source and user-driven, the idea is that no one owns the client. The client owns the solution, which is how it should always have been.
AV.OS is the answer to both. For most of my career I've been the person in between the problem and the solution, and the only compromises in between have been the cost to build and the cost to the client. The idea behind AV.OS is to remove both, and to focus simply on great design, great user experience and more efficiency.
The mission is small and stubborn: show the industry how simple AV control can be.
Myke IrelandTechnology executive, educator and audio creative. Melbourne.
Real screenshots of AV.OS running a demonstration site. Nothing mocked up.
Project
On site
Service

A source lights its path through the room, and only when every device on it confirms. Press Show laptop, and AV.OS shows the switcher routing the input and the display taking it. Every button can show, step by step, what it does.
design · rehearse
Commissioning, against the design. Is each device there, the model and firmware that were designed, linked up, with signal, and does it work? A check that can't be made says so. It's never quietly passed.
commission · prove
Change the room on site, and see the consequences first. Move a cable and AV.OS tells you which buttons now do something else, in the words of the room, what goes off with what, and asks why. One confirmation, not a dozen.
on site · no guessing
Design and reality, always side by side. Every difference from the issued design is recorded with who made it and why. A programmer approves it, or says how it should be. It isn't a failure, and it's never lost.
design ↔ reality
Then run it. Watch availability across the estate, answer the service desk, see incidents explained in plain language with a remedy attached. Sites connect out to Global Control and nothing needs to connect in, so customers can keep everything inside their own firewall.
service · insight
One design for every screen. The same room on a phone, a laptop, a kiosk tablet or a vendor wall panel. The people in the room get big, plain controls and a way to report a problem.
touch · any screenBuilt soft-first, in the open, from publicly documented protocols.
A device is a plain YAML file. The real driver and the simulator are both generated from it, so they can't drift apart.
Rehearse faults before they happen: a PDU outlet off, a device lost from the network, a lock-up. The room reacts the way a real one does.
Intended state against real state, per device and per room, with a transparent score. What can't be verified is reported as unverifiable.
The programmer pushes the design down. Site changes come back up for review. Neither side is silently overwritten.
Incidents, tickets and reports in plain language, with a plain-language remedy for each problem and a workaround where one exists.
Look after hundreds of rooms from one place, with an exportable asset register and a view of what's reaching end of life.
Every device is one plain YAML file, and the library of device definitions is open to everyone: use what's there, or write a definition for the equipment you have. No programming needed, and the checker gives you the line and the fix when something is wrong. Share it back, and everyone gets it.
The programmer designs in a perfect world. The commissioner meets a real one: a cable that didn't arrive, a part that was substituted, a route that has to go round. AV.OS gives them a safe way to change the room, and gives the programmer a clear way to see, approve, or correct what happened.


Draw the new cable, the new plug, the substitute. Nothing is saved yet.
Which controls now do something else, and what goes off with what.
Test just what the change touched. Anything not checked stays marked.
Offer the change to rooms with the same equipment, each one checked first.
The same project runs against a simulator or the real device. Only the connection changes.
The driver and the simulator come from the same definition, so there's one thing to get right.
Rooms run on their own, remember their state and survive a reboot. The cloud is optional.
ARM or x86, from a Raspberry Pi up. A container, not an appliance.
Configuration is human-readable and diffable in git, so a change is a change you can read.
Every control can show what it triggers and what happened. Problems come with a plain-language remedy.
Nothing is called proven until it's proven on real equipment. What can't be checked is said so.
Integrations are separate processes on a published contract, in any language. Your data stays yours.
AV rooms live on corporate networks now, next to people's data. AV.OS is written as if it knows that: a small, boring, well-understood core, permissions that are closed by default, a record of every change, and nothing that needs to dial in.
The AV.OS core is written in Go, the language behind much of today's cloud infrastructure, including Docker, Kubernetes, Terraform and Prometheus. It was chosen for the things an enterprise asks about first: it's memory-safe, strictly typed, compiled to one file, and boring in the best way.
Passwords are hashed with PBKDF2-SHA256 at 200,000 rounds. Sessions are random tokens in HttpOnly cookies, stored hashed, and expire after 12 idle hours. Five roles: programmer, commissioner, operator, service and viewer.
Every request is checked in one place before a room ever sees it. One permission table decides who may do what, and a new action that isn't in it needs a programmer, so nothing is open by accident.
The audit trail logs every request that changes anything, including refusals and sign-ins: who, in what role, where, what, and the result. Passwords, tokens and secrets are redacted before they're written.
Device passwords live on the node that uses them, never in the project file, so a project is safe to share and keep in version control. The API reports whether a secret is set, never what it is.
A project package carries a SHA-256 checksum for every file, verified on import. A package that's been changed, or is missing something, is refused with the reason.
Changes made on site are drafted, reviewed, recorded with who and why, and reviewed again by a programmer. Nothing is silently overwritten, and everything can be undone.
A site opens its own connection to Global Control, outward over ordinary web traffic and through the customer's proxy, so nothing needs opening in the firewall. Remote support is the site's choice: off, asked each time, or pre-approved, with a time limit, and the site can end a session at any moment. Enrolling a site is rate-limited against guessing.
Rooms run without the cloud, keep their state in a local database and survive reboots. The files that matter are written atomically, and inputs are size-limited and validated before they're trusted.
From the first design to the daily service desk.
Everything in AV.OS comes from one definition of the room and one shared record, so what's designed, what's built and what's looked after never drift apart.
AV.OS doesn't make money, and it isn't going to. It's a free platform to show the industry how simple AV control can be. If it's useful to you, here's how to help it get better.
Star and fork on GitHub Open an issue Support the project
Run AV.OS against a real device and report what happened. Every confirmed result makes a definition stronger for everyone.
A device is a YAML file, not code. Add your equipment from its public protocol documentation, and share it back to the library.
Integrators, commissioners, programmers, service techs: say what you need on site. Rants and napkin sketches welcome.
A Go core and a TypeScript console. Small, reviewable pull requests, with tests.
Send it to the integrator who's tired of black boxes, or the educator who wants students to see how a room really works.
No money is made from AV.OS. Coffee helps it get built.
It's a free, open project, so nothing here is for sale and nothing is locked behind a paywall. If it's useful and you'd like to help with development time and design improvements, a coffee goes a long way. It's entirely optional, and a star on GitHub or a good bug report helps just as much.
Buy me a coffee
Turns into evenings. Evenings turn into new device definitions, better screens and fewer rough edges.
☕ Buy me a coffeeWant to contribute, test it or use it? Want it in your rooms, or want to argue about a design decision? Write in.
avos@mykeireland.com