Desktop and systems software

The work that does not fit in a browser

Some problems have to sit close to the machine: capturing a screen frame by frame, encoding video in real time, holding a network session open across packet loss, talking to a device over a serial port, computing geometry fast enough to redraw while someone is still typing. A browser is the wrong place for these, and no framework choice changes that.

This is the work we take on in C++ and Qt6 on Windows, and in .NET where the problem is computation rather than latency. Two of our own products live here, which is why we can discuss the trade-offs concretely instead of in principle.

What we wrote inside trviewer

trviewer is a remote desktop product, and its encryption, video and network layers are ours rather than a library stitched around a sample. Sessions use AES-256-GCM with an ECDH key exchange, and traffic is never decrypted on the relay: the relay forwards bytes it cannot read.

Screen capture runs on the GPU through DXGI and frames are encoded as H.264. When the screen does not change, no frames are produced at all, which is the difference between a session that stays usable on a weak connection and one that saturates it displaying a static desktop.

Transport is hybrid UDP and TCP with XOR forward error correction and adaptive bitrate, because the real problem on a bad line is loss and jitter rather than raw bandwidth. Losing packets degrades the picture instead of dropping the session.

Engineering and CAD tools

ASNCAD produces elevator project drawings from a parameter set: the shaft plan, the car and machine room plans, the longitudinal sections and the complete drawing sheet all come out of the same inputs, so the sheets cannot contradict each other. Alongside the drawings it runs the verification calculations, including traffic analysis, guide rail stress, rope traction, hydraulic buckling and electrical installation.

It began as an add-in inside ZWCAD and ran that way for years. We moved the drawing and calculation engine onto a .NET 8 core so it runs in a browser and on Windows without a CAD licence underneath it. Lifting a proven engine out of the tool it grew up in is a specific kind of work, and we have already done it on our own product.

Devices, formats and protocols nobody documented

A great deal of systems work is integration with something never designed to be integrated with: a controller speaking a vendor protocol, a binary file format with no specification, a legacy service that expects a particular byte order. The work is reverse engineering, careful testing and a wrapper that is easier to live with than what it hides.

We treat the unknown parts as the risk they are and quote them as investigation rather than implementation until we know what is inside.

How a systems project runs

It starts with a feasibility spike, quoted separately and kept short. We build the smallest thing that proves the hard part works on your hardware: the capture runs, the device responds, the throughput is there. Nobody should sign a full project before that question has an answer.

Then the architecture: where the process boundaries are, what runs in which thread, how data moves, what happens when a component dies. In low-level software these decisions are expensive to reverse, so they are made deliberately and written down.

Then implementation in vertical slices with a measurement harness beside it, covering latency, frame rate, memory and throughput, so a regression appears as a number in a run rather than as a complaint months later.

Then soak testing on real hardware. Systems code fails on the eighth hour, under load, on the one machine with a different GPU driver. Short tests never find those.

Shipping on Windows

The last stretch is its own body of work: a signed installer, an update mechanism, running as a service where that is required, behaving correctly under user account control and corporate group policy, and crash reporting that yields something you can actually debug. We budget for it rather than treating it as packaging at the end.