EN
Support Code · soon
In development · stage 1 of 6 complete

More screens. Only what changes travels.

Vitral turns tablets, phones, laptops and boards such as Raspberry Pi into extra monitors for Linux. Instead of sending a flat picture of the desktop, it sends it as layers.

cargo run -r --bin vitral-bench
Try the demo
94%
less data when scrolling
>99%
less data when moving windows
60 fps
sustained on a local link
~3 ms
round trip
0
lines of unsafe code

Layers on the sender.
Memory on the receiver.

The sender describes the screen and the receiver remembers it. Only the difference travels between them.

01Interactive demo

Drag the window.

Compare how much data a flat display would send with what Vitral sends for the same action.

1920 × 1080 · 60 fps

Drag the window with your mouse or finger

Flat display 0 B per frame 0 B total
Vitral 0 B per frame 0 B total
—

Vitral sends only the window’s new position: about 43 bytes per frame.

Drag: estimate based on the compression measured in the benchmark. Scroll, typing and video: measured at 1920×1080.

02Receivers

What you already own, as a monitor.

Desktop receiver for Linux, Windows and macOS, over the network.

03For developers

A small API. No magic.

The engine takes the state of each surface and decides what to send. The receiver only applies messages. All of it verifiable with one command.

sender.rs
// One layer per surface. Only changes leave the machine.
let mut engine = Engine::new(EngineConfig::default());
engine.add_output(0, 1920, 1080, 60_000)?;
engine.create_layer(WINDOW, 0, 864, 648)?;

// Every frame: report state, the engine diffs it.
engine.update_layer(WINDOW, rect, &pixels)?;
engine.place_layer(WINDOW, placement)?;
engine.move_cursor(0, cx, cy, true)?;

for msg in engine.commit(0, now_us)? {
    link.send(&msg)?;
}
terminal
$ cargo run --release --bin vitral-bench

scenario      layered KB/f   flat KB/f   saving   verified
idle                   0.0         0.0       0%      61/61
typing                 6.9         6.9       0%      61/61
scrolling             10.4       176.0      94%      61/61
window drag            0.1       213.7     100%      61/61
video                932.2       932.2       0%      61/61

verified: frames reproduced pixel for pixel.
04How it works

Describe every screen as layers and send only what changes.

  1. 01

    Layers

    The sender describes each screen as a stack of layers: background, windows, video and cursor.

  2. 02

    Cache

    The receiver keeps every layer. Whatever it already has never travels again.

  3. 03

    Only changes

    Only the exact area that changed is sent, compressed losslessly. Moving and scrolling cost bytes.

  4. 04

    Atomic frames

    The picture is assembled only when a frame is committed, never half-built. The cursor always goes first.

05Roadmap

Six stages, each one measured.

  1. 01 Complete

    Protocol core

    Specification v0, engine, receiver, benchmark and tests.

  2. 02 Next

    Real applications

    Nested Wayland compositor: every real window is a layer.

  3. 03 Planned

    Android receiver

    App with hardware composition, USB, touch and stylus.

  4. 04 Planned

    Boards over USB

    Raspberry Pi receiver with direct HDMI output.

  5. 05 Planned

    Linux driver

    Vitral displays show up as real monitors.

  6. 06 Planned

    Video layers

    Hardware encoding and original video without recompression.

06Open source

Open by design.

Vitral uses a different license for each part, according to its role.

ComponentLicenseWhy
Specification and documentationCC-BY-4.0Anyone can implement the protocol.
Protocol and receiver librariesMIT or Apache-2.0Other projects and devices can embed them freely.
Engine and applicationsGPL-3.0Improvements to the applications stay open.
Kernel driverGPL-2.0Required to be part of Linux.

Commercial licenses are available for manufacturers and companies.

Independent design: no part comes from proprietary drivers, firmware or documentation.

07Why

Extra displays deserve better.

For years, adding a USB monitor on Linux has depended on closed software that breaks with every update. Vitral starts from a different idea: an open, documented and measured protocol that anyone can implement on the devices they already own. No black boxes. No dependence on anyone.

08Questions

Frequently asked questions.

Can I use my tablet as a monitor yet?

Not yet. The protocol core is finished and measured; the Android app arrives in stage 3.

Do I need a graphics card?

No. Vitral works with the CPU alone and will use the GPU when one is available.

Does it work on Windows or macOS?

The desktop receiver already runs on all three. The sender starts on Linux.

Is it free?

Yes. Vitral is open source. Companies that need it can obtain commercial licenses.

09Contact

Let’s build more screens.

Collaborations, manufacturers, licensing or simple curiosity.

Emailhola@mirrolabs.com LinkedInYonathan Avendaño A project byMirrolabs