MIAV.OS

Open source · Built in the open

AV.OS

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.

See how it works View on GitHub

A small room you can play with: a laptop and a room PC feed a switcher, which feeds a display and an audio processor with a volume slider, and then an amplifier. A PDU powers the display. Press a source to route it, slide the volume, press the PDU to cut the display's power, or press the amplifier to drop its network link. Laptoptable HDMI Room PCwall input Switcher4x4 matrix in 1 · in 2 → out 1 · out 2 Wall display answeringnot answering: no power Room DSPaudio processor −24 dB Amplifier link up · press menot answering: no link Rack PDUoutlet 1 · press me

Showing: the laptop on the display. Every device on the path confirmed.Press a source · slide the volume · press the PDU or the amplifier

$0Licensing fees. Free to use, free to change
800+Rooms of headroom in the design. It starts on a single Raspberry Pi running one room or a handful
InsideYour firewall. Everything runs behind it, and nothing needs to connect in
0Black boxes. Every control can show what it triggers and what happened
AnyTechnology you like. Integrate through plain data files and a published contract
Why it exists

The gap nobody can see

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.

See it

Two personalities.
One shared brain.

Real screenshots of AV.OS running a demonstration site. Nothing mocked up.

One shared recordThe asset information and design intent that go in at the start are the same information that ends up in the service desk's hands. Every change along the way is documented and recorded, so continuity stays intact and anyone can see where a project is at, at any time.
avos · try the room
AV.OS, Try the room: the Laptop source is lit through the switcher to the wall display, with each device confirming.

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
What's in it

One platform,
many dashboards

Built soft-first, in the open, from publicly documented protocols.

01

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.

02

A simulator you can believe

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.

03

Conformance engine

Intended state against real state, per device and per room, with a transparent score. What can't be verified is reported as unverifiable.

04

Digital twin, both ways

The programmer pushes the design down. Site changes come back up for review. Neither side is silently overwritten.

05

Service desk built in

Incidents, tickets and reports in plain language, with a plain-language remedy for each problem and a workaround where one exists.

06

Fleet and asset register

Look after hundreds of rooms from one place, with an exportable asset register and a view of what's reaching end of life.

Device library

Use what's in the library, or build your own

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 difference

When the site isn't the design, AV.OS says so.

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.

review before you save
The review sheet showing which controls change after a cable is moved.
Advised of the consequences, before you commit.Draft the change and AV.OS shows what it would do before anything is saved: which buttons now do something else, and what goes off with what. You say why, and mistakes are caught before they're made.
not as designed
The Not as designed panel recording a temporary workaround and its reason.
Recorded, never lost.It stays visible through handover and into service until a programmer approves it or restores the design in one step.
01 · Draft

Change freely

Draw the new cable, the new plug, the substitute. Nothing is saved yet.

02 · Review

See what it does

Which controls now do something else, and what goes off with what.

03 · Verify

Check the controls

Test just what the change touched. Anything not checked stays marked.

04 · Reuse

Copy to similar rooms

Offer the change to rooms with the same equipment, each one checked first.

Principles

Eight things it won't compromise on

01

Simulation equals reality

The same project runs against a simulator or the real device. Only the connection changes.

02

One source of truth

The driver and the simulator come from the same definition, so there's one thing to get right.

03

Works offline

Rooms run on their own, remember their state and survive a reboot. The cloud is optional.

04

Small and portable

ARM or x86, from a Raspberry Pi up. A container, not an appliance.

05

Plain text

Configuration is human-readable and diffable in git, so a change is a change you can read.

06

It explains itself

Every control can show what it triggers and what happened. Problems come with a plain-language remedy.

07

Honest about proof

Nothing is called proven until it's proven on real equipment. What can't be checked is said so.

08

Open, with no lock-in

Integrations are separate processes on a published contract, in any language. Your data stays yours.

Security and architecture

Built like infrastructure,
because it is infrastructure.

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.

Architecture: inside the customer's firewall, an AV.OS node runs in one container and talks to the room's devices, to people's browsers and panels, and to separate integrations over a published contract. It opens one connection outward, through the customer's proxy, to Global Control, which looks after many sites. Inside the customer's firewall proxy opened from inside Global Controlmany sites, one view · optional Your integrationsseparate processesany language contract AV.OS nodeone static Go binary · one container · ARM or x86 state in SQLite roles & sign-in audit trail Peoplebrowser, phone, wall panelsigned in, by role The room's devices, on the local network Displays DSP and audio Switchers Conferencing Power (PDUs)
Everything runs inside the customer's network. The only connection that crosses the firewall is one the site opens itself, outward and through the customer's own proxy, and only if they choose to connect a site to Global Control.
The language

Why Go, and why it suits the enterprise

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.

One static binary
No runtime, no interpreter and no package manager on the box. It's pure Go with no C dependencies, built as a single static file and shipped in a minimal, non-root container. Less to patch, and far less to attack.
Memory-safe and strictly typed
The kinds of bug behind many of the worst vulnerabilities in older systems, such as buffer overruns, are largely designed out.
Concurrency, tested properly
A room is hundreds of things happening at once. Go is built for that, and every change runs more than four hundred automated tests with Go's race detector, and is built for x86 and ARM.
Small and stable
Five direct dependencies in the whole core. Go's long-standing compatibility promise means upgrades are routine, not rewrites, which matters when a site has to run for years.
Typed end to end
The web console is TypeScript, and its types are generated from the server's own, with a check that fails the build if they drift. The screen and the server can't quietly disagree.
Behaviour is data, not code
Devices are validated definitions. Rooms are declared in plain, diffable files checked against a schema. On-site changes alter bindings between existing capabilities, never arbitrary code, so what a room does can always be read, reviewed and explained.
01

Sign-in and roles

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.

02

Closed by default

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.

03

A record of every change

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.

04

Secrets stay off the page

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.

05

Tamper-evident packages

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.

06

Guardrails on site edits

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.

07

Nothing dials in

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.

08

Local-first and resilient

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.

What it does

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.

  • ✓Device definitions, simulators and driversGenerated from one plain file per device
  • ✓Real and simulated, side by sideDevices that haven't arrived can still answer, so work carries on
  • ✓Conformance engine and commissioningCheck a room against its design, device by device, with a transparent score
  • ✓Project packagesPre-stage in the simulator and commission anywhere, with every file checksummed
  • ✓Design, delivery and service consoleIncluding change review and design variations
  • ✓Macros and control testingSeveral steps from one press, and a test that presses every control and checks each device did what it was asked
  • ✓Copy to similar roomsChecked room by room before anything changes
  • ✓Room panelsBig, plain controls on a phone, a tablet or a wall panel, with a way to report a problem
  • ✓Service deskIncidents, tickets and reports in plain language, with a remedy for each problem
  • ✓Fleet, asset register and Global ControlOne view above many sites, an exportable asset register and end-of-life tracking
  • ✓Sign-in, roles and audit trailFive roles, closed by default, and a record of every change
  • ✓Open contract for integrationsSeparate programs, in any language, over a published contract
Contribute

Free and open source.

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

01

Put it on real gear

Run AV.OS against a real device and report what happened. Every confirmed result makes a definition stronger for everyone.

02

Write a device definition

A device is a YAML file, not code. Add your equipment from its public protocol documentation, and share it back to the library.

03

Say what's wrong

Integrators, commissioners, programmers, service techs: say what you need on site. Rants and napkin sketches welcome.

04

Code and docs

A Go core and a TypeScript console. Small, reviewable pull requests, with tests.

05

Pass it on

Send it to the integrator who's tired of black boxes, or the educator who wants students to see how a room really works.

Support

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 coffee

Build rooms that explain themselves.

Want 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

View AV.OS on GitHub ↗ Back to myke's site