Renderd v1.0.0

First stable release. Streaming now holds up end to end: low latency, clean quality across screen changes, and sessions that no longer stall after ~10 minutes. This release adds loss recovery by retransmit, resolution that follows the link, and a still screen that always ends on the current picture.

Added

• Nack control message (renderd.proto): the viewer asks the host to resend specific lost fragments. Backward-compatible, so a minor bump.

Performance

• Lost fragments are resent, not paid for with a keyframe. A lost fragment used to go
  unnoticed until four incomplete frames had piled up (on a mostly clean link, never) while the
  frames after it were decoded against a reference the decoder never got, smearing the picture
  until the next keyframe, which on a 3 Mbps link is a quarter of a second of link time. The
  viewer's new ReceiveWindow hands frames to the decoder strictly in order, notices a missing
  fragment as soon as anything after it arrives, and asks for exactly those fragments in a new
  Nack message; the host answers from the last second of datagrams it keeps, and resends the
  newest frame's last datagram after 100 ms of quiet so a lost tail is noticed too. Only a frame
  still missing two round trips plus 120 ms later costs a keyframe, and nothing that depends on
  it is decoded meanwhile. Over loopback QUIC with 5% loss every frame arrives in order with no
  keyframe request. (renderd-frame::receive,
  host::network::retransmit)
• Bitrate steers on real packet loss. The ABR loop used the viewer's frame-loss rate per
  100 ms report (one lost frame among six read as 14%, two as 25%), which walked the bitrate
  down to the floor on any Wi-Fi link. The host now reads QUIC's own packet-loss counters over the
  last second; loss above abr.loss_threshold only stops probing, and the bitrate is cut at five
  times that (or on queuing delay, as before). A 4 Mbps link with 1-3% random loss now holds
  3 Mbps in simulation instead of sinking to 1.5.
• Encoded resolution follows the link. With the default 10 Mbps ceiling a 3 Mbps link still
  got 1080p, and at 2 Mbps a full-screen change of 1080p text is an 83 KB frame (a third of a
  second) against 25 KB at 544p, and no VideoToolbox setting bounds it with low-latency rate
  control. The host now steps the encoder down to 896, 720 or 544 lines when the bitrate falls
  below 75% of what the size needs for 2 s, and back up a rung after 8 s of room, without
  touching capture (VideoToolbox scales). The viewer follows from the stream. On by default;
  host.adaptive_resolution = false turns it off. (host::scale)
• A still screen ends on the current picture. After a big change the low-latency rate
  controller drops the frames that follow it (six of eight in a 2 Mbps measurement), so a scroll
  that stopped inside that window left the viewer on a stale frame until the next change. The
  host now re-encodes the newest captured surface after 60 ms of stillness until two passes come
  out of the encoder. (host::refine)
• HEVC on Windows where the GPU decodes it. --codec auto now offers HEVC first when the GPU
  has the HEVC Main profile and the Media Foundation HEVC decoder runs on it, H.264 otherwise.
• Frames are presented on arrival. The viewer presented through request_redraw, which on
  Windows is a WM_PAINT, the lowest-priority message. It now presents from the wake itself, and
  connects at network.quic_mtu instead of QUIC's 1200-byte minimum.

Fixed

• Keyframe loop on slow links. Frames held up on the wire behind a large one arrive together
  and span more than the 150 ms backlog threshold; the viewer took that for decode falling behind,
  skipped them and asked for another keyframe, which bunched the next frames the same way. A pass
  now only counts as a backlog if the previous one spent 50 ms or more decoding.
• Capture rate at session start. The first vsync report rebuilt the ScreenCaptureKit
  pipeline at every session start and replaced the negotiated frame rate with the viewer's
  refresh rate, lifting a 30 fps session to 60. Vsync now only slows capture, and the rebuild runs
  off the async workers.

Documentation

• README: refreshed status banner, Windows viewer description (DXVA decode, D3D11 presenter, Nack recovery), roadmap and release history.
• release.yml: the release-notes extraction used an awk regex that failed on the tag name, so v0.9.2 and v0.10.0 built but never published. It now matches the heading as a literal string.

Renderd v0.9.1-viewer-stabilization

Pre-release hardening, cross-platform Windows viewer integration, and input forwarding in progress.

• Workspace version bumped from 0.1.0 to 0.9.0-integration to align cargo metadata with the
  CHANGELOG milestone tracking and release tag convention.

• README.md corrected: workspace member count (16 → 15), and the CI section now accurately
  lists each job with its runner OS rather than claiming a generic "Linux/macOS/Windows" matrix.

• CI (ci.yml): Added JUnit XML artifact upload after nextest runs on both macOS and Windows
  jobs (enables GitHub Actions test summary UI). Added a new deny job so cargo deny check
  runs on every PR in addition to the weekly security.yml schedule.

• Security (security.yml): Added documentation comment explaining the relationship between
  the per-PR deny job in ci.yml and the weekly advisory-db drift check in security.yml.

• docs/BENCHMARK-ROADMAP.md: Replaced stale Gantt chart (dates in the past) with an accurate
  status table distinguishing implemented benchmarks from hardware-gated deferred benchmarks.
  Added rationale for deferrals (live display session / GPU runner requirements).

• renderd-crypto: Expanded unit tests from 1 to 9. New tests cover UUID cross-isolation
  (viewer UUID, host UUID), adjacent PIN isolation, output length invariants, non-zero output
  guarantee, and explicit Zeroize::zeroize() invocation for both PairToken and SessionKey.

• renderd-keychain: Expanded MockKeychain tests from 1 to 7. New tests cover
  NotFound error paths (load-missing, delete-missing, double-delete), overwrite semantics
  (save-twice deduplicates), empty-store list, multi-entry isolation, and Arc<MockKeychain>
  shared access pattern.

---

Milestone 9 complete: First End-to-End macOS Display Streaming Milestone.

• First End-to-End macOS Display Streaming: Achieved fully operational live desktop streaming from host capture to viewer presentation.

• Hardware Decoder (VideoToolboxDecoder) Integration: Implemented renderd_VTDecompressionSessionCreateFromNAL and renderd_VTDecompressionSessionDecodeFrame in renderd-vt-sys, replacing the placeholder decoder on macOS.

• Bitstream NAL & Format Description Handling: Added automated VPS (NAL 32), SPS (NAL 33), and PPS (NAL 34) parameter set extraction for HEVC streams to generate valid CMVideoFormatDescriptionRef objects for VideoToolbox decompression sessions.

• Sample Buffer & Length Prefix Conversion: Implemented Annex-B startcode conversion (0x00000001 → 4-byte big-endian NAL length prefixes) matching VideoToolbox HVCC container expectations for hardware decompression.

• Live Desktop Presentation: Verified zero-copy ScreenCaptureKit capture, VideoToolbox HEVC hardware encoding, QUIC datagram transmission, sliding-window reassembly, VideoToolbox hardware decoding, BGRA pixel buffer extraction, and continuous rendering via SoftRenderer.

• Cross-Platform Support: Integrate Windows D3D12/MediaFoundation hardware decoding & swapchain presentation with macOS host daemon.

• Input Forwarding: Mouse, keyboard, and touch event injection from viewer to host.

• Audio & Clipboard: CoreAudio / WASAPI audio streaming and bidirectional pasteboard sync.

• NAT Traversal: STUN/TURN/ICE signaling fallbacks for WAN connections.

Milestone 8 complete: Viewer Application (renderd-viewer).

• Scaffolded renderd-viewer application with native winit event loop, borderless
  fullscreen window management, and Per-Monitor v2 DPI awareness on Windows. (#89)
• Implemented DXGI Allow-Tearing feature check (check_tearing_support()) for safe swap
  chain creation. (#90)
• Implemented D3D12 swap chain and renderer with YUV-to-RGB HLSL pixel shader and
  conditional DXGI_PRESENT_ALLOW_TEARING presentation. (#91)
• Implemented ID3D12VideoDecoder hardware H.265/H.264 video decoder integration with
  GPU VRAM surface output. (#92)
• Implemented QUIC datagram receiver and sliding-window ReassemblyWindow task forwarding
  completed frames to the decoder. (#93)
• Implemented DWM vsync phase reporter querying DwmGetCompositionTimingInfo and
  transmitting VsyncReport over QUIC Stream 0. (#94)
• Implemented dual-timescale ABR feedback exporter: ReactiveStats at 100 ms,
  PeriodicStats at 500 ms, and immediate KeyframeRequest on loss. (#95)
• Implemented viewer pairing UI with SPAKE2+ prover handshake over QUIC Stream 0,
  storing derived PairToken in Windows Credential Manager on success. (#96)
• Implemented reconnect watchdog with mDNS re-discovery filtering by stored host_uuid
  for automatic recovery on host IP change. (#97)
• Implemented semi-transparent Reconnecting... status UI overlay during disconnect
  state without closing window. (#98)
• Implemented Windows system tray icon via Shell_NotifyIcon with context menu:
  "Connect to Host...", "Settings", "Disconnect", "Exit". (#99)
• Added Windows viewer release packaging CI workflow on windows-2025 runner
  (release-viewer.yml) producing standalone installer artifact. (#100)
• Wired HostApp::run() with full subsystem initialization (capture, encode, clock,
  ABR, session, network, UI) and persistent SIGINT/SIGTERM signal handler loop
  replacing placeholder print-and-exit entrypoint. (#101)

---

Milestone 7 complete: Host Application (renderd-host).

• Scaffolded renderd-host application crate with Info.plist, entitlements, and macOS
  app bundle layout. (#76)
• Added macOS app bundle packaging script (tools/bundle-host/assemble.sh). (#77)
• Implemented app startup, CLI argument parsing, Figment config loading, and structured
  panic hook via tracing-subscriber. (#78)
• Implemented macOS login item auto-start using SMAppService.mainApp with enable,
  disable, and status query. (#79)
• Implemented HostSession state machine (IDLE → PAIRING → CONNECTED → STREAMING)
  with typed SessionError transitions. (#80)
• Implemented pairing handler with 6-digit PIN generation, SPAKE2+ verifier protocol,
  exponential failure lockout, and keychain storage. (#81)
• Implemented DeviceRegistry for paired viewer listing and keychain revocation. (#82)
• Implemented CapturePipeline and EncodePipeline wiring ScreenCaptureKit frames
  directly to VideoToolbox encoder via lock-free SPSC ring buffer. (#83)
• Implemented datagram burst sender task fragmenting NAL units and sending non-yielding
  QUIC datagram bursts per frame. (#84)
• Connected ClockController and AbrManager to host control loop processing
  VsyncReport, ReactiveStats, and PeriodicStats messages. (#85)
• Implemented macOS menu bar UI with status icon, pairing PIN display, paired device
  list, and quit action via MenuBar. (#86)
• Implemented NotificationManager posting macOS user notifications on session start
  and device pairing events. (#87)
• Added host release packaging CI workflow (release-host.yml) with code signing,
  notarization, stapling, and DMG artifact creation. (#88)

---

Milestone 6 complete: Algorithm Layer (ABR & Clock Sync).

• Scaffolded renderd-abr crate with pure RampPolicy step-up/step-down bitrate math
  clamped to [5 Mbps, 50 Mbps]. (#64)
• Implemented BandwidthEstimator exponential moving average filter for receive bandwidth
  samples. (#65)
• Implemented AbrEngine dual-timescale state machine: reactive (100 ms, loss-triggered)
  and proactive (500 ms, bandwidth-degradation) bitrate adjustment. (#66)
• Added proptest property tests asserting AbrEngine bitrate decisions remain in
  configured bounds for arbitrary inputs. (#67)
• Added Criterion benchmark for on_reactive and on_proactive ABR decision calls. (#68)
• Scaffolded renderd-clock crate with ClockOffset::compute() for host/viewer clock
  domain translation using QUIC RTT. (#69)
• Implemented JitterFilter median-window outlier rejection for vsync phase reports. (#70)
• Implemented ClockSync state machine with 30-frame warmup, phase tracking, and
  capture pacing output. (#71)
• Added proptest property tests asserting pacing interval is bounded in [8 ms, 33 ms]. (#72)
• Added Criterion benchmark for on_vsync_report and next_capture_time. (#73)
• Created tools/latency-bench CLI skeleton with --frames, --resolution, and
  --codec flag support. (#74)
• Implemented pipeline microsecond stage telemetry with p50/p95/p99/max latency
  reporting across all pipeline stages. (#75)

---

Milestone 5 complete: Service Layer (Net, Keychain & Discovery).

• Implemented ServerTlsConfig and ClientTlsConfig with strict mutual TLS 1.3 and
  pinned certificate verification in renderd-net. (#48)
• Implemented QuicServer and QUIC connection listener in renderd-net. (#49)
• Implemented QuicClient with QUIC connection initiation and TLS handshake in
  renderd-net. (#50)
• Implemented 4-byte length-prefixed control stream framing (send_control /
  recv_control) in renderd-net. (#51)
• Implemented non-yielding FragmentBurst::send_all() datagram burst sender in
  renderd-net. (#52)
• Implemented RTT telemetry exporter via quinn::ConnectionStats in renderd-net. (#53)
• Scaffolded renderd-keychain crate with KeychainStore trait and PairingEntry
  struct. (#54)
• Implemented macOS Keychain Services backend (MacosKeychain) using
  kSecClassGenericPassword. (#55)
• Implemented Windows Credential Manager backend (WindowsCredentialManager) using
  CredWrite / CredRead / CredDelete. (#56)
• Implemented MockKeychain in-memory store for headless testing. (#57)
• Scaffolded renderd-discovery crate with Advertiser and Browser traits and
  ServiceRecord struct. (#58)
• Implemented macOS Bonjour discovery backend using dns_sd.h bindings. (#59)
• Implemented Windows Win32 mDNS backend using DnsServiceRegister / DnsServiceBrowse. (#60)
• Implemented ManualBrowser ...

v0.9.0-integration — Milestone 9: First End-to-End macOS Display Streaming

Renderd v0.9.0-integration — First End-to-End macOS Display Streaming Milestone

Renderd has achieved its first fully operational, real-time end-to-end remote desktop stream on macOS!

Verified Working Pipeline Components

- **Screen Capture**: Zero-copy GPU screen capture via `ScreenCaptureKit` FFI.                                                                                                                            
- **Hardware Encoding**: Real-time HEVC encoding via macOS `VideoToolbox` (`VTCompressionSession`).                                                                                                       
- **Transport**: Sub-16ms peer-to-peer QUIC datagram streaming (`quinn`).                                                                                                                                 
- **Discovery & Handshake**: Local network mDNS peer discovery and QUIC Stream 0 handshake.                                                                                                               
- **Framing & Reassembly**: Sliding-window datagram fragmentation and reassembly (`ReassemblyWindow`).                                                                                                    
- **Hardware Decoding**: Real-time HEVC hardware decompression via `VideoToolbox` (`VTDecompressionSession`).                                                                                             
- **Format Description & NAL Parsing**: Dynamic VPS/SPS/PPS parameter set extraction and Annex-B → HVCC length prefix conversion.                                                                         
- **Frame Extraction & Presentation**: Zero-copy `CVPixelBuffer` BGRA buffer extraction and continuous rendering via `SoftRenderer`.                                                                      

Project Roadmap & Feature Status

- [x] **End-to-End macOS Streaming** (`ScreenCaptureKit` → `VideoToolbox` HW Encode → QUIC → `VideoToolbox` HW Decode → `SoftRenderer`)                                                                   
- [ ] **Cross-Platform Support** (macOS host ↔ Windows D3D12/MediaFoundation viewer integration)                                                                                                          
- [ ] **Input Injection** (Low-latency mouse, keyboard, and touch event forwarding)                                                                                                                       
- [ ] **Audio Streaming** (CoreAudio capture & WASAPI / DirectSound playback)                                                                                                                             
- [ ] **Clipboard Sync** (Bidirectional text & image pasteboard synchronization)                                                                                                                          
- [ ] **File Transfer** (Drag-and-drop peer-to-peer file transport)                                                                                                                                       
- [ ] **WAN / NAT Traversal** (STUN/TURN/ICE signaling fallback)                                                                                                                                          
- [ ] **Performance Optimization** (Zero-copy GPU texture sharing & sub-10ms latency tuning)                                                                                                              

Full Changelog: v0.8.0-viewer...v0.9.0-integration

Renderd v0.8.0-viewer

All 8 milestones complete. Pre-release hardening and end-to-end integration in progress.
Note: renderd-host and renderd-viewer initialize their respective subsystems and run
loops successfully. End-to-end streaming between host and viewer is not yet integrated
— the components are implemented individually and tested in isolation. Full pipeline
integration is planned for v1.0.

---

Milestone 8 complete: Viewer Application (renderd-viewer).

• Scaffolded renderd-viewer application with native winit event loop, borderless
  fullscreen window management, and Per-Monitor v2 DPI awareness on Windows. (#89)
• Implemented DXGI Allow-Tearing feature check (check_tearing_support()) for safe swap
  chain creation. (#90)
• Implemented D3D12 swap chain and renderer with YUV-to-RGB HLSL pixel shader and
  conditional DXGI_PRESENT_ALLOW_TEARING presentation. (#91)
• Implemented ID3D12VideoDecoder hardware H.265/H.264 video decoder integration with
  GPU VRAM surface output. (#92)
• Implemented QUIC datagram receiver and sliding-window ReassemblyWindow task forwarding
  completed frames to the decoder. (#93)
• Implemented DWM vsync phase reporter querying DwmGetCompositionTimingInfo and
  transmitting VsyncReport over QUIC Stream 0. (#94)
• Implemented dual-timescale ABR feedback exporter: ReactiveStats at 100 ms,
  PeriodicStats at 500 ms, and immediate KeyframeRequest on loss. (#95)
• Implemented viewer pairing UI with SPAKE2+ prover handshake over QUIC Stream 0,
  storing derived PairToken in Windows Credential Manager on success. (#96)
• Implemented reconnect watchdog with mDNS re-discovery filtering by stored host_uuid
  for automatic recovery on host IP change. (#97)
• Implemented semi-transparent Reconnecting... status UI overlay during disconnect
  state without closing window. (#98)
• Implemented Windows system tray icon via Shell_NotifyIcon with context menu:
  "Connect to Host...", "Settings", "Disconnect", "Exit". (#99)
• Added Windows viewer release packaging CI workflow on windows-2025 runner
  (release-viewer.yml) producing standalone installer artifact. (#100)
• Wired HostApp::run() with full subsystem initialization (capture, encode, clock,
  ABR, session, network, UI) and persistent SIGINT/SIGTERM signal handler loop
  replacing placeholder print-and-exit entrypoint. (#101)

---

Milestone 7 complete: Host Application (renderd-host).

• Scaffolded renderd-host application crate with Info.plist, entitlements, and macOS
  app bundle layout. (#76)
• Added macOS app bundle packaging script (tools/bundle-host/assemble.sh). (#77)
• Implemented app startup, CLI argument parsing, Figment config loading, and structured
  panic hook via tracing-subscriber. (#78)
• Implemented macOS login item auto-start using SMAppService.mainApp with enable,
  disable, and status query. (#79)
• Implemented HostSession state machine (IDLE → PAIRING → CONNECTED → STREAMING)
  with typed SessionError transitions. (#80)
• Implemented pairing handler with 6-digit PIN generation, SPAKE2+ verifier protocol,
  exponential failure lockout, and keychain storage. (#81)
• Implemented DeviceRegistry for paired viewer listing and keychain revocation. (#82)
• Implemented CapturePipeline and EncodePipeline wiring ScreenCaptureKit frames
  directly to VideoToolbox encoder via lock-free SPSC ring buffer. (#83)
• Implemented datagram burst sender task fragmenting NAL units and sending non-yielding
  QUIC datagram bursts per frame. (#84)
• Connected ClockController and AbrManager to host control loop processing
  VsyncReport, ReactiveStats, and PeriodicStats messages. (#85)
• Implemented macOS menu bar UI with status icon, pairing PIN display, paired device
  list, and quit action via MenuBar. (#86)
• Implemented NotificationManager posting macOS user notifications on session start
  and device pairing events. (#87)
• Added host release packaging CI workflow (release-host.yml) with code signing,
  notarization, stapling, and DMG artifact creation. (#88)

---

Milestone 6 complete: Algorithm Layer (ABR & Clock Sync).

• Scaffolded renderd-abr crate with pure RampPolicy step-up/step-down bitrate math
  clamped to [5 Mbps, 50 Mbps]. (#64)
• Implemented BandwidthEstimator exponential moving average filter for receive bandwidth
  samples. (#65)
• Implemented AbrEngine dual-timescale state machine: reactive (100 ms, loss-triggered)
  and proactive (500 ms, bandwidth-degradation) bitrate adjustment. (#66)
• Added proptest property tests asserting AbrEngine bitrate decisions remain in
  configured bounds for arbitrary inputs. (#67)
• Added Criterion benchmark for on_reactive and on_proactive ABR decision calls. (#68)
• Scaffolded renderd-clock crate with ClockOffset::compute() for host/viewer clock
  domain translation using QUIC RTT. (#69)
• Implemented JitterFilter median-window outlier rejection for vsync phase reports. (#70)
• Implemented ClockSync state machine with 30-frame warmup, phase tracking, and
  capture pacing output. (#71)
• Added proptest property tests asserting pacing interval is bounded in [8 ms, 33 ms]. (#72)
• Added Criterion benchmark for on_vsync_report and next_capture_time. (#73)
• Created tools/latency-bench CLI skeleton with --frames, --resolution, and
  --codec flag support. (#74)
• Implemented pipeline microsecond stage telemetry with p50/p95/p99/max latency
  reporting across all pipeline stages. (#75)

---

Milestone 5 complete: Service Layer (Net, Keychain & Discovery).

• Implemented ServerTlsConfig and ClientTlsConfig with strict mutual TLS 1.3 and
  pinned certificate verification in renderd-net. (#48)
• Implemented QuicServer and QUIC connection listener in renderd-net. (#49)
• Implemented QuicClient with QUIC connection initiation and TLS handshake in
  renderd-net. (#50)
• Implemented 4-byte length-prefixed control stream framing (send_control /
  recv_control) in renderd-net. (#51)
• Implemented non-yielding FragmentBurst::send_all() datagram burst sender in
  renderd-net. (#52)
• Implemented RTT telemetry exporter via quinn::ConnectionStats in renderd-net. (#53)
• Scaffolded renderd-keychain crate with KeychainStore trait and PairingEntry
  struct. (#54)
• Implemented macOS Keychain Services backend (MacosKeychain) using
  kSecClassGenericPassword. (#55)
• Implemented Windows Credential Manager backend (WindowsCredentialManager) using
  CredWrite / CredRead / CredDelete. (#56)
• Implemented MockKeychain in-memory store for headless testing. (#57)
• Scaffolded renderd-discovery crate with Advertiser and Browser traits and
  ServiceRecord struct. (#58)
• Implemented macOS Bonjour discovery backend using dns_sd.h bindings. (#59)
• Implemented Windows Win32 mDNS backend using DnsServiceRegister / DnsServiceBrowse. (#60)
• Implemented ManualBrowser static IP fallback for corporate network environments. (#61)
• Implemented DiscoveryError hierarchy (BindFailed, ServiceRegistrationFailed,
  BrowseFailed). (#62)
• Implemented MockConnection in-memory transport for integration testing. (#63)

---

Milestone 4 complete: FFI Layer (VideoToolbox & ScreenCaptureKit shims).

• Scaffolded renderd-vt-sys crate with build.rs linking VideoToolbox, CoreMedia, and
  CoreFoundation frameworks. (#36)
• Implemented renderd_VTCompressionSessionCreate C bridge shim for Rust FFI callback
  compatibility. (#37)
• Implemented CompressionSession safe Rust wrapper with H.265 real-time hardware encoder
  initialization and Drop cleanup. (#38)
• Implemented dynamic bitrate control (set_bitrate) and force-keyframe trigger in
  CompressionSession. (#39)
• Implemented IOSurface Rust wrapper with CFRetain/CFRelease lifetime management. (#40)
• Implemented VtError OSStatus decoder with human-readable error messages. (#41)
• Scaffolded renderd-sc-sys crate with ObjC2 ScreenCaptureKit framework imports. (#42)
• Implemented ScreenRecordingPermission::check() TCC authorization query. (#43)
• Implemented ContentFilter::main_display() display enumeration and selection. (#44)
• Implemented ScreenStream wrapper with GPU-resident frame callback on
  QOS_CLASS_USER_INTERACTIVE GCD queue. (#45)
• Implemented dynamic minimumFrameInterval vsync pacing controls on ScreenStream. (#46)
• Implemented ScError hierarchy (PermissionDenied, NoDisplaysFound,
  StreamFailed). (#47)

---

Milestone 3 complete: Primitive Layer (Frame & Crypto).

• Added 16-byte fixed binary fragment header codec (FragmentHeader) in renderd-frame
  crate per RFC-0002 §12.1. (#23)
• Added type-safe fragment header bitfield flags (FragmentFlags) in renderd-frame
  crate. (#24)
• Added Fragment and CompleteFrame types in renderd-frame crate. (#25)
• Added sliding-window fragment reassembly buffer state machine (ReassemblyWindow) in
  renderd-frame crate per RFC-0002 §12.2. (#26)
• Added dynamic fragment deadline computer (DeadlineComputer) in renderd-frame. (#27)
• Added proptest property tests for reassembly window safety under arbitrary reordering. (#28)
• Added Criterion benchmark for reassembly window throughput. (#29)
• Scaffolded renderd-crypto crate with PairToken and SessionKey types with
  Zeroize on drop. (#30)
• Added RFC 9382 SPAKE2+ test vectors as unit test suite. (#31)
• Implemented SPAKE2+ Prover and Verifier state machines for P-256 pairing. (#32)
• Implemented HKDF-SHA256 key derivation helpers (derive_pair_token,
  derive_session_key) with canonical info strings. (#33)
• Implemented TLS certificate generator (generate_cert) using rcgen with pair token
  derived key material. (#34)
• Added Criterion benchmarks for crypto operations (derive_pair_token,
  generate_cert). (#35)

---

Milestone...

Renderd v0.7.0-host

Milestone 3 in progress: Core Data Structures & Utilities
(renderd-frame, renderd-clock, renderd-abr).

• Added 16-byte fixed binary fragment header codec (FragmentHeader) in renderd-frame
  crate per RFC-0002 §12.1. (#23)
• Added type-safe fragment header bitfield flags (FragmentFlags) in renderd-frame
  crate. (#24)
• Added fragment header validation logic (ValidateHeader trait) in renderd-frame
  crate. (#25)
• Added sliding-window fragment reassembly buffer state machine (ReassemblyBuffer) in
  renderd-frame crate per RFC-0002 §12.2. (#26)
• Added property-based tests for fragment header codec and reassembly buffer in
  renderd-frame crate. (#27)
• Added high-resolution monotonic clock instant wrapper (MonoInstant) in
  renderd-clock crate per RFC-0002 §13.1. (#28)
• Added 4-timestamp NTP/PTP monotonic clock epoch estimator (ClockEpochEstimator) in
  renderd-clock crate per RFC-0002 §13.2. (#29)
• Added stack-allocated rolling statistics ring buffer (RollingStats) in renderd-clock
  crate per RFC-0002 §13.3. (#30)
• Added integration test suite for clock offset estimation and rolling statistics in
  renderd-clock crate. (#31)
• Added ABR state machine enum (AbrState) in renderd-abr crate per RFC-0002 §14.1.
  (#32)
• Added ABR decision engine (AbrEngine) calculating target bitrates per RFC-0002 §14.2.
  (#33)
• Added ABR telemetry report converter (TelemetryReport) processing PeriodicStats and
  ReactiveStats in renderd-abr crate per RFC-0002 §14.3. (#34)
• Added ABR unit and property-based test suite in renderd-abr crate. (#35)

---

Milestone 2 complete: Foundation Layer.

• Added Protobuf protocol schema definition in proto/renderd.proto per RFC-0002 §11.
  (#13)
• Added tools/proto-gen code generator and generated prost Rust types in
  renderd-proto crate. (#14)
• Added protocol domain newtypes (FrameId, FragmentId, BitrateKbps,
  VsyncPeriodNs, ViewerId, HostId) in renderd-proto crate. (#15)
• Added envelope dispatch helpers (MessageKind) and message validation logic for
  SessionHello and SessionConfig in renderd-proto crate. (#16)
• Enabled proto freshness CI check step in .github/workflows/ci.yml. (#17)
• Added configuration schema structs (RenderdConfig, HostConfig, ViewerConfig,
  NetworkConfig, CryptoConfig, AbrConfig) in renderd-config crate. (#18)
• Added Figment-based layered config loader (ConfigBuilder) supporting defaults, TOML
  files, environment variables, and CLI overrides in renderd-config crate. (#19)
• Added configuration validation rules (ValidateConfig trait) for RenderdConfig in
  renderd-config crate. (#20)
• Added ConfigError enum hierarchy (FileNotFound, ParseError, ValidationError)
  and Display implementations in renderd-config crate. (#21)
• Added canonical host and viewer default configuration templates
  (renderd-host.default.toml, renderd-viewer.default.toml) and template validation
  integration tests. (#22)

---

Milestone 1 complete: Repository Bootstrap & Infrastructure.

• Initialized Cargo workspace root with resolver v2 and declared all 15 member crates
  across 5 DAG layers (crates/renderd-*, tools/latency-bench, tools/proto-gen)
  per REPO-0001. (#1)
• Added rust-toolchain.toml pinning Rust stable channel (MSRV 1.80) with
  aarch64-apple-darwin, x86_64-pc-windows-msvc, and aarch64-pc-windows-msvc
  target support. (#1)
• Configured workspace-level dependency versions, lint policies, and build profiles
  (dev, release, bench). (#1)
• Configured workspace-level clippy.toml setting msrv = "1.80", disallowing
  std::process::exit and std::env::var, and restricting raw array pair-tokens.
  (#2)
• Added per-crate lint overrides: unsafe_code = "deny" for non-FFI crates;
  unsafe_code = "warn" for FFI crates (renderd-vt-sys, renderd-sc-sys) per
  REPO-0001 §9. (#2)
• Added root .rustfmt.toml workspace formatting configuration per REPO-0001 §10.
  (#3)
• Configured cargo-deny policy in deny.toml for license checking, dependency bans,
  and security advisory checking per REPO-0001 §9. (#4)
• Added test runner configuration in nextest.toml per REPO-0001 §14.7. (#5)
• Added primary CI workflow in .github/workflows/ci.yml per REPO-0001 §18.1. (#6)
• Added security audit workflow in .github/workflows/security.yml per
  REPO-0001 §18.2. (#7)
• Added nightly benchmark workflow in .github/workflows/bench.yml per
  REPO-0001 §18.3. (#8)
• Added code ownership rules in .github/CODEOWNERS per REPO-0001 §7.1. (#9)
• Added PR template and GitHub Issue forms for bug reports, latency regressions, and
  feature requests. (#10)
• Added spell-checking configuration in _typos.toml and
  .github/workflows/typos.yml. (#11)
• Added documentation deployment workflow in .github/workflows/docs.yml per
  REPO-0001 §18.5. (#12)

---

Milestone 6 – Windows Viewer Engine (Phase 1 - Architecture)

Milestone 6 Progress Update

Release: v0.6.0-alpha.1

This pre-release marks the completion of the initial Windows Viewer architecture for Renderd.

The foundational application structure is now in place, providing the framework that future Milestone 6 work will build upon. While networking, rendering, decoding, and presentation are not yet fully integrated, the viewer now has a production-oriented architecture capable of supporting the remaining implementation work.

---

Highlights

Windows Viewer Architecture

• Scaffolded the renderd-viewer crate.
• Established the primary application lifecycle.
• Added centralized configuration and error handling.
• Introduced shared application state and runtime metrics.

Window Management

• Implemented the Win32 application lifecycle using winit.
• Added Per-Monitor V2 DPI awareness.
• Added native window creation.
• Added resize event handling.
• Added fullscreen abstraction.
• Introduced platform-specific initialization.

Renderer Abstraction

• Added a renderer trait defining the graphics lifecycle.
• Implemented a NullRenderer backend for testing.
• Defined initialization, resize, rendering, presentation, and shutdown interfaces.

Decoder Abstraction

• Added a decoder trait.
• Implemented a NullDecoder.
• Defined decoded frame representations.
• Established the decoder lifecycle.

Frame Pipeline

• Added a bounded thread-safe frame queue.
• Implemented automatic queue overflow handling.
• Added stale frame eviction.
• Prepared the producer/consumer pipeline for future networking integration.

Application State

• Added centralized viewer state management.
• Added connection state tracking.
• Added runtime metrics.
• Prepared shared state for future transport integration.

---

Internal Improvements

• Refactored viewer modules into well-defined abstractions.
• Improved separation of concerns throughout the viewer crate.
• Applied workspace formatting.
• Maintained zero Clippy warnings.
• Maintained passing CI across Linux, macOS, and Windows.

---

Verification

Verified with:

• cargo fmt
• cargo clippy --workspace --all-targets -- -D warnings
• cargo nextest run --profile ci
• GitHub Actions CI

---

Current Milestone Status

Milestone 6 remains in progress.

Completed work includes the foundational viewer architecture and platform integration. Remaining work will focus on graphics rendering, media decoding, transport integration, and end-to-end frame presentation before the milestone is considered complete.

Renderd v0.5.0-networking

Renderd v0.5.0-networking

Milestone 5 — Networking, Discovery & Secure Pairing

Pre-release

This is an early development release intended for testing and contributor feedback. APIs, crate interfaces, and implementation details may change before the first stable release.

---

Highlights

Networking Foundation

• Added renderd-net crate
• QUIC networking abstraction
• QUIC client wrapper
• QUIC server wrapper
• Control stream framing
• Fragment datagram burst sender
• RTT telemetry exporter
• In-memory transport implementation for deterministic testing

Secure Pairing

• Added renderd-keychain crate
• Cross-platform KeychainStore abstraction
• macOS Keychain backend
• Windows Credential Manager backend
• Mock keychain backend for headless testing

Service Discovery

• Added renderd-discovery crate
• Bonjour (mDNS) backend for macOS
• Windows DNS-SD / mDNS backend
• Manual IP discovery fallback
• Unified discovery traits and error hierarchy

Cross-platform Improvements

• Updated Windows bindings for the latest windows crate
• Fixed Windows Credential Manager bindings
• Updated Windows DNS-SD bindings
• Improved platform-specific FFI wrappers
• Resolved all Windows CI compatibility issues
• Verified successful builds on macOS, Windows, and Linux

Quality & Tooling

• Expanded unit and integration test coverage
• Added deterministic networking and keychain mocks
• Improved GitHub Actions reliability
• Modernized Dependabot configuration
• Simplified CODEOWNERS
• Repository-wide formatting, linting, and documentation improvements

---

CI Status

All continuous integration checks are passing.

• ✅ Linux
• ✅ macOS
• ✅ Windows
• ✅ Cargo Tests
• ✅ Nextest
• ✅ Clippy
• ✅ Rustfmt
• ✅ Documentation
• ✅ Protocol Validation
• ✅ Typos

---

New Crates

• renderd-net
• renderd-keychain
• renderd-discovery

---

Milestone Summary

• Completed Issues #48 – #63
• All Milestone 5 issues completed and closed
• Cross-platform CI fully passing
• Repository ready for Milestone 6 development

---

Next Milestone

Milestone 6 will focus on integrating the networking stack with the host and viewer pipelines, bringing Renderd closer to a functional end-to-end remote desktop streaming prototype.

---

Thank you to everyone following the development of Renderd!

## What's Changed
* ci(deps): bump softprops/action-gh-release from 2 to 3 by @dependabot[bot] in https://github.com/Ad1th/Renderd/pull/113
* ci(deps): bump actions/deploy-pages from 4 to 5 by @dependabot[bot] in https://github.com/Ad1th/Renderd/pull/112
* ci(deps): bump actions/upload-pages-artifact from 3 to 5 by @dependabot[bot] in https://github.com/Ad1th/Renderd/pull/111

## New Contributors
* @dependabot[bot] made their first contribution in https://github.com/Ad1th/Renderd/pull/113

**Full Changelog**: https://github.com/Ad1th/Renderd/compare/v0.4.0-platform...v0.5.0-networking

Renderd v0.4.0-platform

Milestone 3 in progress: Core Data Structures & Utilities
(renderd-frame, renderd-clock, renderd-abr).

• Added 16-byte fixed binary fragment header codec (FragmentHeader) in renderd-frame
  crate per RFC-0002 §12.1. (#23)
• Added type-safe fragment header bitfield flags (FragmentFlags) in renderd-frame
  crate. (#24)
• Added fragment header validation logic (ValidateHeader trait) in renderd-frame
  crate. (#25)
• Added sliding-window fragment reassembly buffer state machine (ReassemblyBuffer) in
  renderd-frame crate per RFC-0002 §12.2. (#26)
• Added property-based tests for fragment header codec and reassembly buffer in
  renderd-frame crate. (#27)
• Added high-resolution monotonic clock instant wrapper (MonoInstant) in
  renderd-clock crate per RFC-0002 §13.1. (#28)
• Added 4-timestamp NTP/PTP monotonic clock epoch estimator (ClockEpochEstimator) in
  renderd-clock crate per RFC-0002 §13.2. (#29)
• Added stack-allocated rolling statistics ring buffer (RollingStats) in renderd-clock
  crate per RFC-0002 §13.3. (#30)
• Added integration test suite for clock offset estimation and rolling statistics in
  renderd-clock crate. (#31)
• Added ABR state machine enum (AbrState) in renderd-abr crate per RFC-0002 §14.1.
  (#32)
• Added ABR decision engine (AbrEngine) calculating target bitrates per RFC-0002 §14.2.
  (#33)
• Added ABR telemetry report converter (TelemetryReport) processing PeriodicStats and
  ReactiveStats in renderd-abr crate per RFC-0002 §14.3. (#34)
• Added ABR unit and property-based test suite in renderd-abr crate. (#35)

---

Milestone 2 complete: Foundation Layer.

• Added Protobuf protocol schema definition in proto/renderd.proto per RFC-0002 §11.
  (#13)
• Added tools/proto-gen code generator and generated prost Rust types in
  renderd-proto crate. (#14)
• Added protocol domain newtypes (FrameId, FragmentId, BitrateKbps,
  VsyncPeriodNs, ViewerId, HostId) in renderd-proto crate. (#15)
• Added envelope dispatch helpers (MessageKind) and message validation logic for
  SessionHello and SessionConfig in renderd-proto crate. (#16)
• Enabled proto freshness CI check step in .github/workflows/ci.yml. (#17)
• Added configuration schema structs (RenderdConfig, HostConfig, ViewerConfig,
  NetworkConfig, CryptoConfig, AbrConfig) in renderd-config crate. (#18)
• Added Figment-based layered config loader (ConfigBuilder) supporting defaults, TOML
  files, environment variables, and CLI overrides in renderd-config crate. (#19)
• Added configuration validation rules (ValidateConfig trait) for RenderdConfig in
  renderd-config crate. (#20)
• Added ConfigError enum hierarchy (FileNotFound, ParseError, ValidationError)
  and Display implementations in renderd-config crate. (#21)
• Added canonical host and viewer default configuration templates
  (renderd-host.default.toml, renderd-viewer.default.toml) and template validation
  integration tests. (#22)

---

Milestone 1 complete: Repository Bootstrap & Infrastructure.

• Initialized Cargo workspace root with resolver v2 and declared all 15 member crates
  across 5 DAG layers (crates/renderd-*, tools/latency-bench, tools/proto-gen)
  per REPO-0001. (#1)
• Added rust-toolchain.toml pinning Rust stable channel (MSRV 1.80) with
  aarch64-apple-darwin, x86_64-pc-windows-msvc, and aarch64-pc-windows-msvc
  target support. (#1)
• Configured workspace-level dependency versions, lint policies, and build profiles
  (dev, release, bench). (#1)
• Configured workspace-level clippy.toml setting msrv = "1.80", disallowing
  std::process::exit and std::env::var, and restricting raw array pair-tokens.
  (#2)
• Added per-crate lint overrides: unsafe_code = "deny" for non-FFI crates;
  unsafe_code = "warn" for FFI crates (renderd-vt-sys, renderd-sc-sys) per
  REPO-0001 §9. (#2)
• Added root .rustfmt.toml workspace formatting configuration per REPO-0001 §10.
  (#3)
• Configured cargo-deny policy in deny.toml for license checking, dependency bans,
  and security advisory checking per REPO-0001 §9. (#4)
• Added test runner configuration in nextest.toml per REPO-0001 §14.7. (#5)
• Added primary CI workflow in .github/workflows/ci.yml per REPO-0001 §18.1. (#6)
• Added security audit workflow in .github/workflows/security.yml per
  REPO-0001 §18.2. (#7)
• Added nightly benchmark workflow in .github/workflows/bench.yml per
  REPO-0001 §18.3. (#8)
• Added code ownership rules in .github/CODEOWNERS per REPO-0001 §7.1. (#9)
• Added PR template and GitHub Issue forms for bug reports, latency regressions, and
  feature requests. (#10)
• Added spell-checking configuration in _typos.toml and
  .github/workflows/typos.yml. (#11)
• Added documentation deployment workflow in .github/workflows/docs.yml per
  REPO-0001 §18.5. (#12)

---

v0.3.0-primitives

Renderd v0.3.0-primitives

Primitive Layer complete.

This release establishes the core protocol primitives that will power Renderd's low-latency display streaming pipeline.

While Renderd is not yet capable of streaming a desktop, the underlying algorithms and shared infrastructure for fragmentation, reassembly, adaptive bitrate control, and clock synchronization are now implemented, tested, and integrated.

Highlights

Frame Pipeline

• Fixed-size binary fragment header codec
• Fragment serialization and parsing
• Header validation
• Sliding-window frame reassembly
• Property-based reassembly testing
• Reassembly benchmarking

Cryptography

• SPAKE2+ authentication state machines
• RFC 9382 test vectors
• HKDF key derivation helpers
• Certificate generation utilities
• Cryptographic benchmarking

Timing & Adaptation

• High-resolution monotonic clock abstraction
• Clock offset estimation
• Rolling latency statistics
• Adaptive bitrate (ABR) congestion control
• Telemetry processing
• Bitrate decision engine

Engineering

• RFC-0002 compliant implementation
• Strict crate boundaries
• Zero unsafe code in primitive crates
• Property-based testing
• Full CI/CD validation
• Documentation deployment
• Repository-wide formatting and linting
• Cross-platform compatibility improvements

Current Status

Completed

• ✅ Repository Bootstrap
• ✅ Foundation Layer
• ✅ Primitive Layer

Upcoming

• macOS FFI bindings
• ScreenCaptureKit integration
• VideoToolbox bridge
• CoreFoundation wrappers
• CoreGraphics abstractions

⚠️ Renderd is still in active development.

No desktop capture or streaming functionality is available yet.

The next release will introduce the platform abstraction layer required to interface directly with macOS capture and encoding APIs.

Full Changelog: v0.2.0-foundation...v0.3.0-primitives

v0.2.0-foundation

Renderd v0.2.0-foundation

Foundation Layer complete.

This release establishes the core shared infrastructure that every subsequent Renderd component will build upon.

While Renderd is not yet capable of streaming a display, the protocol definitions, configuration system, validation, serialization, and supporting infrastructure are now implemented and validated.

Highlights

Protocol

• Protobuf schema implementation
• Protocol code generation
• Message envelope definitions
• Serialization and deserialization
• Validation layer

Configuration

• Layered configuration system
• TOML configuration loading
• Environment overrides
• Strongly typed configuration models
• Configuration validation
• Default configuration templates

Quality

• RFC-0002 compliant implementation
• REPO-0001 compliant crate boundaries
• Full workspace linting
• CI verification
• Unit and integration tests
• Documentation generation

Status

Completed:

• ✅ Repository bootstrap
• ✅ Foundation layer

Upcoming:

• Primitive Layer
  • Frame representation
  • Reassembly engine
  • Cryptography
  • TLS identity
  • SPAKE2+ pairing

⚠️ This is still a pre-release intended for development and contributor testing.

No end-user display streaming functionality is available yet.

Full Changelog: v0.1.0-bootstrap...v0.2.0-foundation