RemoteHub

A modern hub for remote Windows administration: remote desktop sessions, a PowerShell console, file transfer, registry editor, services and processes – organised in folders with inherited settings and credentials. It's built with .NET 10 (LTS), WPF and Fluent design (WPF-UI), and uses the Microsoft RDP client built into Windows (mstscax.dll). PowerShell remoting uses the PowerShell 7.6 SDK.

Formerly "RDP Manager". The rename (internal build 2.0, before the version numbers were reset to 0.x – see Versioning & releases) changed the product, program (RemoteHub.exe), installer, code and settings folder. Upgrading keeps everything:

• The installer replaces an installed RDP Manager (same upgrade code); the Start menu entry and install folder are now RemoteHub.
• On the first start, %APPDATA%\RdpManager is copied to %APPDATA%\RemoteHub (settings, remembered shared-file key, log). The old folder is left as a backup and can be deleted later.
• A shared folder that already has RdpManager.settings keeps using that file, so PCs with older versions keep syncing; new shared folders get RemoteHub.settings. The IT policy key HKLM/HKCU\SOFTWARE\Policies\RemoteHub is read first, …\Policies\RdpManager still works.
• Backups are now *.rhbackup; older *.rdpmbackup files can still be imported.
• The remoting setup script creates firewall rules named RemoteHub-WinRM-HTTPS-In / -HTTP-In and removes a rule of the old name (RdpManager-WinRM-…) when it runs. Targets set up earlier keep working without running it again.

Build & run

dotnet build
dotnet run --project src/RemoteHub
dotnet test

Installer (MSI)

powershell -ExecutionPolicy Bypass -File build/build-installer.ps1

Optional parameters: -Version 0.9.0 (default: <Version> in src/RemoteHub/RemoteHub.csproj), -Configuration Release, -OutputPath artifacts. This builds:

• artifacts/RemoteHub-<version>-x64.msi: a self-contained, per-machine install (no .NET runtime needed) that adds a Start menu shortcut.

• artifacts/RemoteHub-Agent-<version>-x64.msi: the RemoteHub Agent for devices. A copy ships inside RemoteHub (Agent\RemoteHub-Agent-x64.msi), so RemoteHub can install it. The build runs RemoteHubAgent.exe selftest on the published agent.

• Silent install: msiexec /i RemoteHub-0.11.0-x64.msi /qn. Silent uninstall: msiexec /x … /qn.

• .rdp files: the installer registers RemoteHub under "Open with" and in Settings → Default apps. It doesn't take the default away from mstsc. To make RemoteHub the default, use Settings → General → Use RemoteHub for .rdp files…, or set it through IT policy (a default-associations XML).

• Building uses the WiX Toolset v5 MSBuild SDK, which comes from NuGet at build time, so nothing extra has to be installed.

Versioning & releases

• 0.x = pre-release. Versions stay below 1.0 until the first GA release, which will be 1.0.0. Builds made before the move to GitHub were numbered up to 2.1.0; they were reset to 0.9.0 (same features as 2.1.0).

• Format: major.minor.patch (e.g. 0.9.1), optionally with a pre-release suffix (0.9.1-beta.1). An MSI only knows three numeric parts, so a fourth part would be ignored by upgrades. The program file shows the same version with .0 appended (e.g. 0.9.0.0).

• The git tag is the version. Pushing a tag v0.9.1 runs .github/workflows/release.yml: restore, build, run the tests, build the MSI with build/build-installer.ps1 -Version 0.9.1, and publish a GitHub Release with the MSI attached. Tags below 1.0 or with a suffix are marked as pre-releases. Keep <Version> in the csproj in step (it's used for local builds); the workflow warns when it differs from the tag.

• Every push and pull request to main runs .github/workflows/ci.yml (build and tests).

• Cutting a release:

  git tag -a v0.9.1 -m "RemoteHub 0.9.1"
  git push origin v0.9.1

• Downgrade from an older 2.x install: the MSI refuses to install over a higher version. Uninstall RemoteHub 2.x first (settings in %APPDATA%\RemoteHub are kept), then install 0.9.x.

• Not yet in place: code signing. The MSI and the program are unsigned, so SmartScreen may warn when they're downloaded.

Features

• Folders with inheritance. Credentials and every RDP setting can be set on a folder. Sub-folders and connections inherit them, or override them one value at a time ("Inherit · value" shows what the parent would give).
• Saved credentials (Settings → Security & storage → Manage saved credentials…): named credentials that any folder, connection or the global defaults can reference. Editing one updates every item that uses it.
• Local accounts on standalone servers: tick Local account on the target computer (.\user) (or type .\admin). The credential then signs in with that local account on whichever server you connect to, so one folder credential covers many non-domain servers.
  • Windows' default policy refuses to send saved passwords to servers it can only verify via NTLM, which is typical for non-domain servers. You'll see "The server's authentication policy does not allow connection requests using saved credentials". That's a Windows policy (it affects mstsc too), not an app setting. Either allow saved credentials for those servers ("Allow delegating saved credentials with NTLM-only server authentication" → TERMSRV/<server>, via IT or Group Policy), or turn off NLA for those connections.
• How passwords reach the server: RemoteHub uses the Microsoft RDP client API (mstscax.dll, not mstsc.exe) and hands the stored password to the session in memory right before connecting – no clipboard involved.
• Server refuses saved credentials ("Your credentials did not work … does not allow connection requests using saved credentials"): the server requires the password to be entered in Windows' Windows Security dialog on every connection (e.g. "Always prompt for password upon connection"). RemoteHub does not get around this. Setting Security & session → When Windows asks for the password (inherited per folder/connection, default in Settings → Connection defaults):
  • Copy to clipboard (default): the stored password is put on the clipboard so you can press Ctrl+V and OK; a notice appears at the bottom centre of the RemoteHub window. It is excluded from clipboard history (Win+V) and cloud clipboard and cleared after 30 s or right after a successful login. Other open RDP sessions with clipboard redirection could paste it in the meantime.
  • Do nothing: type it yourself.
  • The dialog is matched to the session by the username it shows when that is readable; otherwise the dialog must belong to RemoteHub (or have no owner) and exactly one session must have started connecting within the last 60 s. Otherwise nothing is copied.
  • To avoid the prompt entirely, the server's owner can review the "Always prompt for password upon connection" policy for that host.
  • Settings → Help & about → Open diagnostic log shows what happened (no passwords, usernames or host names are logged).
• Search (Ctrl+F) finds folders and connections by name, host, notes and folder path; several words narrow the results (prod sql). Enter or double-click opens a connection or jumps to a folder; right-click → Show in list. If nothing matches, Enter quick-connects to the typed computer name.
• Beside each connection's name: when it was last used (today 15:42, yesterday, Mon, 12 Oct – any tab: RDP, agent desktop, PowerShell, tools), or never connected. The agent shield's tooltip shows the agent's version.
• Clean up: the filter button next to the search shows connections not used for 30 days, 90 days, 6 months or a year (oldest first), or never connected – combine it with a search. Delete these… removes all of them after one question. Use is recorded from RemoteHub 0.13.1 on – a connection without a recorded use only counts once that is longer ago than the chosen time.
• Icons & colours (editor → Appearance): choose one of ~35 built-in icons (server, database, cloud, firewall, laptop …) or your own image (PNG/ICO/JPG, scaled to 64 px and stored in the settings file). Colours: palette swatches or a custom #RRGGBB, inherited from the folder (e.g. a red Production folder). The colour is used for the icon in the list, the tab and the session frame.
• Clear separation from other windows: solid, tinted window colours instead of see-through effects, an accent-coloured window border (Windows 11), and the app icon plus the session name in the title and taskbar. Each session sits in a frame with a header (name, address); the frame lights up in the session's colour while the keyboard goes to the remote session ("Keyboard → remote session").
• Connection defaults (Settings → Connection defaults) sit at the root of the inheritance chain.
• Drag & drop: move connections and folders around the tree, and drop .rdp files anywhere in the window to import them.
• .rdp export: right-click a connection → Save as .rdp file…, or right-click a folder → Export folder as .rdp files…. The effective (inherited) settings are written. You can optionally include the password; it's encrypted for the current Windows user, as mstsc does.
• Single instance: opening a .rdp file while the app is running hands it to the open window, which reuses an existing entry for the same server.
• Startup protection (Settings → Security & storage → Startup protection…, off by default): RemoteHub asks for a startup password – or Windows Hello (PIN, fingerprint or face) – every time it starts.
  • What it protects: everything RemoteHub stores on this PC – the key of the local database (connections, credentials, audit log) and the remembered password of a shared settings file – is encrypted with a random 256-bit key, inside the existing Windows (DPAPI) encryption. That key is stored only wrapped: with the startup password (PBKDF2-SHA256, 600,000 iterations, AES-256-GCM) and, if chosen, with Windows Hello (a Hello key of this PC, kept in the TPM where available, signs a fixed challenge; its SHA-256 wraps the key). Without the password or Hello the settings can't be opened, also not by other programs running under your Windows account or from a copy of the files.
  • Turning it on (or off) encrypts the database with a new key stored with the new protection – a copy of the old key can't open it any more – and removes the previous copies (.bak, the moved settings.dat, older database backups). If an old %APPDATA%\RdpManager folder exists, you can delete that unprotected copy in the same step.
  • Changing the password, adding or removing Windows Hello, turning it off: same menu; each needs the current password. A new password also gets a new key (an old copy of lock.json with the old password opens nothing); Windows Hello is set up again for it.
  • Lock when you're away (same menu, Never by default): after 5, 15, 30 or 60 minutes without mouse or keyboard input on this PC, RemoteHub hides its windows, wipes the key from memory and asks for the password or Windows Hello. Sessions, transfers and recordings keep running. It waits while a dialog is open.
  • Keep the password safe: without it – and without Windows Hello on this PC – the settings on this PC can't be recovered. Export a backup first. Windows Hello is per PC and per Windows user.
  • It doesn't protect against malware that runs while RemoteHub is unlocked (while locked, the database key stays in memory for the running sessions), and a shared settings file keeps its own password (other PCs aren't affected).
• Navigation toolbar: New (new connection, new folder, import .rdp files), the gear for Settings, and hide navigation. Everything else lives in Settings.
• Settings (the gear or Ctrl+,): one window with a page per group.
  • RemoteHub: General (theme, session switch keys, .rdp files), Updates & privacy, Security & storage (startup protection, saved credentials, where the settings are stored, backup), Recordings (frame rate, video size, graphics card capture, folder), Logs (audit log and how long it keeps entries, diagnostic log), Help & about.
  • Connection defaults: credentials, display, local resources & keyboard, security & session, PowerShell remoting, colour, and the refresh intervals of the remote tools.
  • Editing a connection or folder uses the same layout (General, Appearance, Credentials, Display, …).
• Updates (Settings → Updates & privacy): RemoteHub checks https://update.remotehub.dev/latest in the background a few seconds after it starts – nothing waits for it. If a newer version exists, a bar at the top offers it; Details… shows the release notes and Download and install.
  • Only a higher version is ever installed. Beta versions compare like SemVer (0.9.1-beta.1 < 0.9.1).
  • Channels: GA (stable releases) or Beta (pre-releases, ?channel=beta). Below 1.0 the default is Beta, because there is no GA release yet. Switching from Beta to GA doesn't go back to an older version.
  • Verified download: the MSI is downloaded over HTTPS from GitHub or remotehub.dev only, and must match the SHA-256 checksum and size the update server announces. Otherwise it's deleted and not installed.
  • Install: RemoteHub closes (asks first if sessions or transfers are open), Windows asks for administrator approval, the MSI installs, and RemoteHub starts again.
  • Skip this version hides that version at start-up; Settings → Updates & privacy → Check for updates now checks any time. A release the server marks as mandatory (or a version below its minSupportedVersion) is shown right away and can't be skipped.
  • While the GitHub repository is private, the download only works for accounts with access to it; the window then offers the releases page.
• Anonymous usage data (Settings → Updates & privacy, on by default; full list in PRIVACY.md, which is also installed next to RemoteHub.exe): small POSTs to https://update.remotehub.dev/telemetry at start-up, in the background with a 5-second limit, errors ignored. Every request contains exactly event, version, channel, os (Windows 10 / 11 / Server), arch (x64 / arm64) and installId, plus:
  • app_start (each start): the counts connections, agents (connections with the agent installed), shares (SMB / SFTP / FTP / WebDAV, below a server or on their own) and folders – numbers only.
  • app_session (next start): runSeconds, how long the previous session ran, with that session's version. Tracked in %LOCALAPPDATA%\RemoteHub\run-time.json, updated once a minute and at exit, so a crash still counts; time the PC sleeps doesn't count.
  • app_crash (below): errorType, message and stack.
  • The install ID is a random GUID created once and stored in %LOCALAPPDATA%\RemoteHub\install-id. It's not derived from the computer name, MAC address or machine SID, so it only counts installs. Turning telemetry off deletes it and the run-time file.
  • Nothing about connections, servers, credentials, user or computer names is sent. Like any web request, the server sees the public IP address. The server keeps usage data and crash reports for 365 days.
  • Settings → Updates & privacy → Open privacy statement opens PRIVACY.md in Notepad.
  • Debug builds never send it.
• Crash reports (same switch and policy as the usage data): if RemoteHub crashes, it only writes a small file to %LOCALAPPDATA%\RemoteHub\crash – nothing is sent while the app is going down. The next start sends it in the background as event: "app_crash" to the same endpoint, with errorType, message and stack (that start also sends its normal app_start).
  • .NET exceptions that end the app: the exception type, its message and the call stack (with inner exceptions' types and stacks). The same for unexpected errors RemoteHub survives (it shows them in a message box) – at most three per session.
  • Native crashes (e.g. inside the Microsoft RDP client) never reach .NET. RemoteHub marks each session as running and clears the mark on a clean exit; if the mark is still there at the next start, Windows' Application Error event (1000) of that session gives the faulting module and exception code (errorType: "NativeCrash"). Without such an event it's reported as UnexpectedExit (e.g. ended in Task Manager or power loss).
  • Redacted before it's stored: paths, user, computer and domain names (also other DOMAIN\user names), host names, IP (also shortened IPv6) and e-mail addresses, and quoted values. Message is limited to 500 characters, stack to 8,000.
  • At most 5 reports wait to be sent, none older than 30 days. With usage data off they're deleted instead of sent. Errors the app recovers from (the "unexpected error" message) aren't reported.
• IT policy (HKLM or HKCU\SOFTWARE\Policies\RemoteHub), shown as managed in Settings:
  • DisableTelemetry (DWORD 1): no usage data.
  • DisableUpdateCheck (DWORD 1): never contacts the update server (e.g. when updates come through software deployment).
  • UpdateChannel (string stable or beta): fixes the channel.
  • SettingsFolder (string): shared settings folder, as before.
  • DisableRecording (DWORD 1): tabs can't be recorded (the Record button is hidden).
  • RecordingFolder (string, environment variables allowed): where recordings are saved; users can't change it.
  • AuditRetentionDays (DWORD 1–36500): how long the audit log keeps entries (default 365); wins over the setting in Settings → Logs.
• Settings → Help & about → Settings overview… shows every setting in one place – where the settings are stored, global defaults, refresh intervals of the remote tools, credentials (counts only, never passwords or user names), theme and keys, and how many folders and connections there are – with buttons to change each part. Copy as text puts it on the clipboard for support.
• Settings → Help & about → About RemoteHub… shows the version, developer and copyright, build date, .NET, Windows, remote desktop client (mstscax.dll), PowerShell SDK and WPF-UI versions, and where the program, settings and log are. Copy version info copies it.
• What's in which folder: every folder is framed together with everything in it – in the folder's colour with a light tint of it (a neutral frame for folders without a colour; sub-folders get their own frame inside). Each folder also shows how many items it holds (empty when none). Hover over a folder or connection (also in search results) to see where it is (e.g. LAB › NUC13 or Top level › NUC13) and where its credentials come from. Dragging an item into or out of a folder so that its credentials change (e.g. dropped just below a folder, which puts it at the top level) asks first and shows the old and the new source.
• Navigation sidebar: collapse it to a slim rail with the button in its header or Ctrl+B (expand / new connection / new folder / search stay available). The state and width are remembered per PC. The status dot next to a connection uses the same colours as its tab: green = connected, amber = connecting, red = failed, grey = open but disconnected.
• Tabs grouped by connection: one tab per connection (name, status dot; for a single PowerShell / file transfer / registry / services / processes tab also its icon). Only when a connection has more than one tab (e.g. remote desktop + registry) does a second row appear below with that connection's tabs – Remote desktop, PowerShell, File transfer, Registry, Services, Processes – each with its own status dot; the connection tab then shows how many are open. + next to the connection tabs (or right-click a tab) opens another tab for the selected connection; tools that need PowerShell remoting reuse the credentials of an open remoting tab. Selecting a connection shows the tab you used last there. Middle-click closes a tab; on a connection tab it closes all tabs of that connection (also Close all in its right-click menu). Closing a tab moves to the next tab of the same connection first.
  • Ctrl+Alt+< (the < > | key left of Y on German keyboards) goes to the next session, and Ctrl+Alt+Shift+< to the previous one. It also works while a session has keyboard focus and in full screen; switching from full screen keeps the next session in full screen. Use the left Alt key: AltGr+< still types | (in the app and in sessions), because AltGr = Ctrl+Alt on German layouts. Other choices are under Settings → General → Session switch keys: Ctrl+Alt+^, F1/F2, PageUp/PageDown, Left/Right.
  • Ctrl+Tab also switches (when the app has focus), Ctrl+W closes a session, and Ctrl+F searches or quick-connects (type a host and press Enter).
• Session actions: reconnect, disconnect, Ctrl+Alt+Del, full screen (native RDP connection bar), record, detach into a separate resizable window, and dock back.
• Recording (every tab type: remote desktop, PowerShell, file transfer, registry, services, processes): the Record button in the tab toolbar (also in the tab's right-click menu and in detached windows) starts and stops it.
  • While recording: the button turns into a red REC 01:23 that stops it; the tab, its connection tab and the tab header show a red REC badge.
  • What's recorded: the tab's content – the remote screen, the console, the lists. With Include the connection details (Settings → Recordings) also the bar above it (which connection, its address, how it connects); plus the mouse pointer and a date/time stamp in the corner. Other windows on top aren't recorded. By default the picture is taken with GDI (about 10 fps). Capture with the graphics card (Windows.Graphics.Capture, off by default) is needed for 30/60 fps; on Windows 10 Windows may show a yellow frame around RemoteHub while it records. Turn it off again if the PC becomes unstable while recording. While the tab isn't visible (another tab selected, window minimized), the video shows a placeholder. A remote desktop in full screen records its monitor. No sound.
  • Frame rate and size (Settings → Recordings, for the next recording): 5, 10 (default), 15, 30 or 60 fps; video size same as the tab (default, up to 4K), Full HD (1920 × 1080) or 4K (3840 × 2160) – the tab is scaled into the fixed sizes, with black bars when the shape differs. For presentations: 30 fps and Full HD or 4K. Higher values need more CPU and make larger files; if capturing can't keep up, single frames are skipped and the video stays in sync. Measured with graphics card capture on a 22-thread PC: Full HD reaches 30 / 55 of 60 fps, 4K reaches 29 of 30 fps; 4K at 60 fps reaches about 32 fps (limited by Windows' software H.264 encoder).
  • File: MP4 (H.264, Windows' own encoder – nothing to install; quality-based, so a still screen costs almost nothing – roughly 0.5 MB per 10 s of typical console work at 1920 × 1080 and 10 fps) in Videos\RemoteHub, named <connection> - <tab> - <date time>.mp4. Change the folder in Settings → Recordings. The file is written as fragmented MP4, so what was recorded stays playable if RemoteHub or Windows stops unexpectedly. The size is fixed when recording starts; later size changes of the tab are scaled to fit.
  • Stop: with the button, by closing the tab, or by exiting RemoteHub (exit asks first and saves the recordings). Afterwards Play, Show in folder or Delete recording… (asks first; the file goes to the Recycle Bin).
  • Recordings aren't encrypted and can contain personal data and passwords shown on screen. The first recording asks for confirmation once.
• Clipboard redirection is on by default. It works host ↔ session, and therefore across sessions.
• Windows key forwarding (per connection or inherited): Win, Alt+Tab and similar keys go to the session while it has focus.
• Dynamic resolution: the remote desktop follows the window size. Smart sizing and fixed resolution are also available.

PowerShell remoting (console, file transfer, registry, services, processes)

Right-click any connection → Test PowerShell remoting to check it by hand. To check automatically, turn on Settings → PowerShell remoting → Check automatically after RDP login (or per folder / connection; inherited like every other setting, default off). It uses the same (inherited) credentials as the RDP connection. With no credentials set, your own Windows account is used (Kerberos).

• Automatic check (when switched on): after the first successful RDP login of a connection, RemoteHub opens a WinRM session in the background (port 5985, or 5986 with Use HTTPS) and reads the PowerShell version. The result (available / not available, the reason and when) is stored with the connection in the settings file, so it is kept across restarts. It is shown in the connection editor.
• Right-click a connection or its tab:
  • available → PowerShell, File transfer, Registry, Services and Processes
  • not checked yet / not available → Test PowerShell remoting (again), which shows the result and the reason. If opening a PowerShell tab later fails, the connection is marked as not available again.
• PowerShell tab: opens a new remote session to the host, as a tab next to the RDP sessions (detachable like them). Output is formatted on the remote computer, with colours for Write-Host, warnings and errors. Tab completes against the remote session: one match is inserted directly; several open a list above the input line (Tab/↓ next, Shift+Tab/↑ previous, Enter accepts, Esc restores what you typed; Ctrl+Space always opens the list). The list also opens by itself after typing - (parameters, or after Get-), . (members) or \ (paths); nothing is pre-selected then, so Enter still runs the line. Typing narrows the open list. Completion uses the remote computer's own TabExpansion2, so it works with Windows PowerShell 5.1 and PowerShell 7 targets. The input line and the commands echoed in the output are colour-coded like PSReadLine (commands, parameters, strings, variables, numbers, keywords, operators, types, comments), using PowerShell's parser on this PC. The current folder comes from the remote session. Also: ↑/↓ history, Ctrl+C stops the running command (or copies selected text), Ctrl+L / cls clears, exit closes the tab. Read-Host and confirmation prompts are answered on the input line; passwords (Get-Credential, -AsSecureString) in a dialog. Not supported: full-screen console programs and single-key input (ReadKey).
• File transfer tab (right-click → File transfer, or the File transfer button of a PowerShell tab, which opens at that tab's current folder): a split view with this PC on the left and the remote computer on the right. The remote side starts at C:\ (or the last remote folder of that connection); the local side starts at the last local folder.
  • Each side has an address bar: type or paste a path and press Enter (environment variables such as %TEMP% are expanded on that side; empty or This PC shows the drives). There's also Up (Backspace), Refresh (F5) and New folder. Double-click or Enter opens a folder.
  • Only the folder that is shown is loaded: one remote call each time you open a folder. Nothing is scanned in the background. Hidden files are dimmed.
  • Drag & drop: local → remote uploads, remote → local downloads. You can also drop files from Explorer onto the remote side, or drop onto a folder row to put the files into that folder. The arrow buttons in the middle transfer the selection. Folders are transferred with their contents. If items already exist, you choose Overwrite or Skip existing.
  • Right-click (or keys) on the remote side: Download to the local folder, Rename… (F2), Delete… (Del; asks first – folders are deleted with their contents, and there is no recycle bin for remote deletes; drive roots are refused), New folder…, Copy path, Refresh (F5). On the local side: Upload, Show in Explorer, New folder…, Copy path, Refresh.
  • Dragging remote files directly into Explorer isn't supported; drop them on the local side (or use Download).
  • Files dropped on a PowerShell tab are uploaded into its current folder.
  • Transfers run over their own session.
    • Uploads are streamed in 1 MB chunks without waiting for an answer per chunk, and many small files share one call, so folders with thousands of files don't pay a round trip per file. At most 8 MB are in flight.
    • Compression: every file, also inside folders, is gzip-compressed on the way where that saves at least 10 %. Already-compressed formats (zip, msi, images, video …) and incompressible data are sent as they are. The target always writes the original, decompressed file: no archive or .gz file is left behind, and nothing is installed on the target (decompression uses .NET's GZipStream, which is part of Windows).
    • On the target, every file's SHA-256 is compared with the source before it gets its final name:
      • Files larger than 1 MB are written to <name>.remotehub-part and renamed once verified.
      • Smaller files arrive in one piece, are verified in memory and then written directly. This avoids a rename per file, which costs about 10 ms each where a virus scanner checks renamed files.
      • Cancelled or failed transfers leave nothing behind.
      • Without "overwrite", existing files are found first and not sent at all.
    • Measured through the RemoteHub Agent on a simulated VPN (30 ms, 100 Mbit/s): 300 small files went from 95 s to 2 s, a 32 MB log from 11.5 s to 2.9 s, and a 32 MB incompressible file from 11.4 s to 8.5 s.
    • Downloads still use the previous method: 1 MB per request, then a checksum.
    • Speed: each file of 1 MB or more shows its current speed while running and its average when done. The pane header shows the overall current speed and the average over the time files were actually moving (idle gaps between transfers don't count). Uploads count the original size, also when sent compressed.
    • Cancel: each transfer has its own cancel button; Cancel all (in the File transfers pane, also on its collapsed rail) cancels every running and waiting transfer. Finished files stay, partial files are removed. Progress, speed and result appear in the File transfers pane on the right (styled like the navigation: resizable, collapses to a slim rail with the number of running transfers, width remembered per PC; it appears when a transfer starts), and the destination side refreshes when a transfer is done.
• Registry tab (right-click → Registry): the remote computer's registry like regedit – keys on the left, values (name, type, data) of the selected key on the right.
  • Address bar: type or paste a key and press Enter. HKLM\…, HKLM:\…, HKEY_LOCAL_MACHINE\…, Registry::… and regedit's Computer\… all work. The tree expands down to the key. It starts at the last key used for that connection (first time: HKEY_LOCAL_MACHINE\SOFTWARE).
  • Only the key that is opened is read (one remote call per key, sub keys load when you expand them). The 64-bit registry view is used. HKEY_CURRENT_USER is the profile of the account used for remoting, not of the user logged on via RDP.
  • Values: double-click or Enter edits (DWORD/QWORD in hex or decimal, multi-string one per line, binary as hex bytes). Right-click → Modify…, Rename… (F2), Delete… (Del), Copy name, Copy data, New → string, expandable string, multi-string, DWORD, QWORD or binary value. Expandable strings are shown and saved unexpanded.
  • Keys: right-click → New (key or value), Rename… (F2; a real rename like regedit, permissions are kept), Delete… (Del; the key and everything below it), Export… (saves the key as a .reg file on this PC, made by reg export on the remote computer), Copy key path, Refresh (F5).
  • Safety: every change is a single action you start; deleting keys or values always asks first and can't be undone (export first). Hives and the keys directly below them (e.g. HKLM\SOFTWARE) can't be deleted or renamed here. What you may change is decided by the remote account's permissions (HKLM needs an administrator). Value data is never written to the diagnostic log. Importing .reg files isn't offered.
• Services tab (right-click → Services): the remote computer's services like the Services console – name with a status dot, status, startup type, service name, Log on as, PID and description.
  • Start, Stop and Restart in the toolbar or the right-click menu; stop and restart ask first (running services that depend on it are stopped too). Each waits up to 60 s for the service and reports if it doesn't get there.
  • Right-click → Startup type → Automatic, Automatic (delayed start), Manual or Disabled (Disabled asks first). Details… (or double-click / Enter) shows path and description; Copy service name / display name / path.
• Processes tab (right-click → Processes): the remote computer's processes like Task Manager's details – name, PID, CPU %, working set, private bytes, user, session, threads, handles, start time and command line. The status line shows the number of processes, total CPU and memory use.
  • CPU % is the average since the previous refresh (the second reading follows 2 s after opening). User names need an administrator account on the target.
  • End process (Del) and End process tree (Shift+Del, also ends everything it started) ask first; several processes can be selected. Critical Windows processes (System, csrss, wininit, winlogon, services, lsass, smss, …) and the tab's own remoting process can't be ended from here. Copy name / PID / path / command line.
• Both lists: click a column header to sort (again to reverse), Ctrl+F or the filter box narrows the list (name, PID, user, status, …), F5 refreshes now. Rows are updated in place, so selection and sorting stay. They refresh automatically while the tab is visible – processes every 15 s, services every 60 s by default; change it (or turn it off) under Settings → Remote tools. The pause button in the tab stops the automatic refresh for that tab. Every action is written to the diagnostic log (what was done, not the names).
• Passwords: taken from the connection's credentials and passed in memory only. If a credential has no password, you're asked when connecting; that password is kept only for that tab and isn't saved.
• Requirements on the target: WinRM / PowerShell remoting enabled (Enable-PSRemoting), port 5985 (HTTP) or 5986 (HTTPS with a certificate this PC trusts) reachable, and the account must be an administrator or a member of Remote Management Users. Over HTTP, the WinRM traffic is encrypted by Kerberos/NTLM.
• Computers outside the domain or addressed by IP can't use Kerberos. For NTLM over HTTP, Windows only sends credentials to hosts in this PC's WinRM TrustedHosts list. RemoteHub does not change that list. Use Use HTTPS for those connections, or have an administrator add specific hosts to TrustedHosts (avoid *). Certificate checks are never skipped.
• Setting up a target: when a test fails, RemoteHub offers Set up on the target… (also right-click → Set up PowerShell remoting on the target…). It builds a ready-to-run script for an elevated PowerShell on the target. Copy it (it isn't saved in clipboard history and is cleared after 120 s) or save it as .ps1, paste it into the target's PowerShell (e.g. in its RDP session), run it, then click Test again. RemoteHub never runs the script itself.
  • Already filled in: all addresses of this PC (IPv4 and routable IPv6 of every active network adapter; the one used to reach the host comes first). You can change the list, e.g. add a subnet when NAT or VPN is in between. Only IP addresses or subnets are accepted. The script runs Enable-PSRemoting and adds a firewall rule (RemoteHub-WinRM-HTTPS-In / -HTTP-In) that allows WinRM only from those addresses. The script header lists every change and how to undo it; set $DryRun = $true at the top to only show what it would do.
  • HTTPS (recommended, required for IP addresses and computers outside the domain): RemoteHub creates a certificate for that one target: RSA 3072, 2 years, the host name or IP address as its name, server authentication only, and not a CA. The script installs it in LocalMachine\My and binds the WinRM HTTPS listener (5986) to it. If an HTTPS listener already exists, its certificate is replaced, and the script warns about it. This PC trusts the certificate for your Windows account (CurrentUser\Root, shown as "RemoteHub – WinRM "; Windows asks you to confirm), and the connection switches to HTTPS. The private key exists only in the script; RemoteHub doesn't keep it. Delete a saved .ps1 after use. To remove the trust later, open certmgr.msc → Trusted Root Certification Authorities.
  • HTTP: only for domain computers reached by name (Kerberos).
• Local accounts (.\user) are sent as COMPUTER\user, using the first part of the host name (.\user for IP addresses).

RemoteHub Agent (without WinRM)

For devices where WinRM / PowerShell remoting isn't allowed. A small Windows service on the device gives RemoteHub the same PowerShell session over its own TLS connection, so PowerShell, file transfer, registry, services and processes all work as with remoting. WinRM can stay off. Design and protocol: docs/agent-spec.md.

• Use it: a connection's (or folder's) Settings → PowerShell remoting → Connect through → RemoteHub Agent. Right-click → Test RemoteHub Agent checks it.
• Install: right-click the connection → Install RemoteHub Agent…. RemoteHub creates a new identity for the device: a certificate (RSA 3072, 2 years, the device ID as its name). It stores only that certificate's SHA-256 fingerprint with the connection. Then it delivers the agent MSI and the device's enrollment file (<label>.rhagent, which contains the device key):
  • Silently over PowerShell remoting, when remoting works for the connection. Both files are copied to a temp folder on the device, checked with a checksum, and installed with msiexec /qn. RemoteHub then checks that the installed certificate is the one it created, and deletes the folder.
  • Through the clipboard otherwise. Both files go to the clipboard: paste them into the RDP session (same folder) and run the MSI as administrator. This needs clipboard redirection. The first successful connection confirms the install. The copies on this PC are deleted when RemoteHub closes.
  • Update (when it's installed): through the running agent, over remoting, or with the clipboard. The device keeps its certificate unless you choose Create a new device certificate.
• On the device:
  • Service RemoteHub Agent (RemoteHubAgent), running as LocalSystem, set to Automatic (Delayed Start) and restarted on failure.
  • Default port 58732.
  • Firewall rule RemoteHub Agent, limited to the agent program, its port and the Allow connections from addresses.
  • Certificate in LocalMachine\My (key not exportable); configuration in %ProgramData%\RemoteHub\Agent\agent.json; daily logs in …\logs, kept 30 days.
  • Uninstalling removes the rule, the certificate and the configuration.
• Security:
  • RemoteHub only accepts the device's own certificate. On a mismatch it stops before sending any credentials.
  • You sign in with a Windows account of the device, either a local account (LAPS works) or one of the device's domain, so no domain trust to your PC is needed. By default only administrators are allowed.
  • The agent checks the password on the device as a network logon, so policies such as "Deny access to this computer from the network", account lockout and the Security log apply. PowerShell then runs as that user (an administrator's full token under UAC).
  • After 5 failed sign-ins within 5 minutes, the source address is refused for 5 minutes.
  • The agent sends nothing anywhere: no telemetry, no logs.
• Requirements: Windows 10 1809 / Server 2019 or later, with Windows PowerShell 5.1 (built in). If AppLocker or WDAC blocks PowerShell or forces Constrained Language Mode, the agent is limited the same way remoting would be.
• Troubleshooting on the device:
  • "C:\Program Files\RemoteHub Agent\RemoteHubAgent.exe" selftest checks TLS, the endpoints and the sign-in check without changing anything.
  • The agent's log is in %ProgramData%\RemoteHub\Agent\logs.
  • For a failed silent install, RemoteHub shows the relevant lines from the msiexec log.

Remote desktop through the agent (without RDP)

For desktops where RDP is turned off: with the agent installed, RemoteHub shows the device's screen and sends mouse and keyboard over the agent's own connection (same port, same pinned TLS, same Windows sign-in). Design: docs/agent-desktop-draft.md.

• Use it: Remote desktop opens through the agent when one is installed (setting Remote desktop through: Automatic / RDP / RemoteHub Agent under PowerShell remoting). RDP is always one click away: right-click → Remote desktop via RDP, or Use RDP instead in the tab.
• In the tab: choose the Windows session (console or any signed-in session), how the signed-in user is involved, view-only, and the picture (Slow connection 15 fps, Admin work 30 fps (default), Sharp, Smooth 60 fps). While connected:
  • Monitor switch, or All monitors in one picture (scaled down when it is larger than 4096 × 2304).
  • Fit to window (on by default): the device's resolution follows the tab like RDP's dynamic resolution – the exact size when the display takes it, else the same shape a little smaller, else the listed mode that fills the tab best – and goes back when you disconnect.
  • Key combinations (on by default): while the tab has the focus, Alt+Tab, the Windows key and its combinations go to the device, not to this PC (like the RDP client). Ctrl+Alt+Del and Windows+L always stay with this PC – use the Ctrl+Alt+Del button.
  • Connection info: frames per second, data rate, round trip, the device's current quality and how it captures, and what the last resolution change did.
  • Clipboard both ways: text as soon as you copy; images, and files and folders (up to 100 MB and 1000 files per copy; more → use the file transfer) only when they are pasted on the other side. Copying offers them (names and sizes); files appear as virtual files, like RDP does it – Explorer may look at the list at any time, the contents are transferred when something pastes them, with progress in the desktop tab and a confirmation from the device. Programs that read every new clipboard entry (RDP's clipboard sync, Windows' clipboard history) get nothing. Files copied to the device land in the signed-in user's temp folder (RemoteHub Clipboard) and are read and written with that user's rights, never the agent's. While connected, the device's display is kept on (and woken if it went dark).
  • Reconnect: if the network drops (Wi-Fi, VPN), RemoteHub reconnects for up to 30 s. The user isn't asked again as long as the user who allowed it is still the one signed in (a single-use token from the agent, valid for a minute, for the same account).
  • Recording works like any tab.
• Disconnected sessions: when the Windows session's RDP connection is closed, it has no screen – RemoteHub says so over the still picture and continues when someone connects to it again.
• Your own account: signing in on the device with the account you connected with (or connecting to your own session) asks nobody – there is nobody else to ask.
• Your own RDP session: when the session you pick is connected by RDP from this PC, RemoteHub warns you – the RDP window moves your mouse to follow the remote pointer. Minimize it while you control the session here, or connect from another PC.
• RDP windows on the device: Remote Desktop Connection stops the server drawing a session while its window is minimized, so an agent connection to that session would show black. While you are connected, the agent sets RemoteDesktop_SuppressWhenMinimized = 2 for the signed-in user of the session you see, so RDP windows there keep drawing when minimized, and puts the user's own value back (or removes it) when the connection ends. RDP windows opened before need to reconnect once.
• The user at the device:
  • Ask them: a RemoteHub window asks to allow it (denied when nobody answers in time).
  • Show them a code: the device shows a 6-digit code that they read out to you (3 attempts).
  • Connect without asking: off by default – needs a policy that adds None to AllowedConsentModes and grants the ConsentBypass right.
  • Nobody is asked when nobody is signed in (the sign-in screen is shown) or the session is locked (the lock screen is shown). The mode you choose then applies to whoever unlocks or signs in: the picture stops at their desktop and continues only after they allow it (or read out the code). If they refuse, the session ends. Anyone other than the user who allowed it is asked again, also when RemoteHub follows the console into another session.
  • While connected, a banner at the top of their screen always says who is viewing (or controlling), with Disconnect; after a few seconds it shrinks to a small pill (it opens again under the mouse). From Windows 10 2004 / Server 2022 it isn't part of the picture you see; on older Windows (e.g. Server 2016/2019) it is, because Windows would paint it black otherwise.
  • Signing in, locking and switching users don't end the connection: the agent follows the console into the new session (the banner shows again at once; anyone other than the user who allowed it is asked first). It ends when the user clicks Disconnect, or after repeated failures.
• Privacy:
  • The user at the device can always hide their screen with Hide screen on the banner: Black out (you get one black frame, then nothing – no picture, no pointer) or Blur (a blurred picture so nothing can be read, at most 2 frames a second). Your mouse, keyboard and Ctrl+Alt+Del don't reach the device until they click Show screen; the tab says so. It is hidden or blurred on the device itself – nothing readable is sent. It stays hidden after a dropped connection or a new helper (sign-in) as long as the same user is there.
  • You can black out the device's screen with the privacy screen button next to Ctrl+Alt+Del: plain black, or a dark screen with the RemoteHub logo and "Remote Support Session in Progress". You keep seeing the desktop; the person at the device sees the privacy screen, with the banner (and Disconnect) above it. The device's own mouse and keyboard are blocked with it by default (clicks on the banner and Ctrl+Alt+Del still work there); untick it in the menu, or turn it off for the device with the policy PrivacyScreen = 1. Needs Windows 10 2004 / Server 2022 or later on the device (older Windows can't keep a window out of the picture). Not covered yet: UAC prompts, the Ctrl+Alt+Del screen and the sign-in screen (a separate desktop) – see docs/privacy-mode-design.md §5.7.
  • The user at the device can also hide single apps: Hide apps… on the banner, in the question (Allow and hide apps…) or next to the code. They tick running apps; their windows are covered in your picture – also when they are opened, moved, restored or appear on another monitor later – and taskbar previews, Alt+Tab, Task View and notifications are covered while any app is hidden. You can't click or type into a hidden app, and what is copied there isn't sent to you. You see how many apps are hidden and "Hidden by the user" where they are – never which apps. While a hidden window moves or opens, your picture pauses for a moment.
  • Both are audited (who, when, which style or how many apps – never what was on the screen or which apps).
• How it works: the service starts a helper in the chosen session as LocalSystem, so the sign-in screen, the lock screen and UAC prompts can be shown and used. Picture: Desktop Duplication (only what changes; GDI on VMs without a GPU), H.264 in low-latency mode, at most 2 frames ahead of what RemoteHub has shown, quality lowered automatically on slow connections.
• Policy on the device (HKLM\SOFTWARE\Policies\RemoteHub\Agent, read for every connection; wins over agent.json):
  • DesktopEnabled (DWORD 0): remote desktop off.
  • AllowedConsentModes (REG_MULTI_SZ): any of Ask, Pin, None (default Ask, Pin).
  • ConsentTimeoutSeconds (DWORD, 5–600, default 30).
  • MaxFramesPerSecond (1–60), MaxQuality (1–100).
  • DesktopClipboard (DWORD): 0 off, 1 text, 2 text and images, 3 text, images and files (default).
  • DesktopIdleTimeoutMinutes (DWORD, 0–1440, default 0 = never): a session without mouse or keyboard input for this long ends, after a warning shortly before. View-only sessions count too (they have no input).
  • AuditToEventLog (DWORD 0): audit entries only in the log file, not in the Windows Application log.
  • PrivacyScreen (DWORD): 0 the privacy screen is off; 1 allowed, but the mouse and keyboard at the device stay usable; 2 allowed and the mouse and keyboard at the device are blocked with it (default; the admin can untick it per session).
  • HiddenApps (REG_MULTI_SZ): apps never shown to an admin, whatever the user chooses – full program paths (C:Program FilesKeePassKeePass.exe) or aumid: and a Store app's AppUserModelID.
  • TunnelEnabled, TunnelTargets, TunnelPorts, MaxTunnelStreams: the device as a jump host – see Jump hosts below.
  • Subkey Rights, values PowerShell, Desktop, DesktopViewOnly, SecureDesktop, ConsentBypass, PrivacyScreen, Tunnel (REG_MULTI_SZ, group SIDs or names). Default: the agent's allowed groups (Administrators) for everything except view-only and ConsentBypass (nobody).
  • If the policy key exists but can't be read, the agent allows nothing until it can (logged).
• Ctrl+Alt+Del (the button) is sent by the agent service for the console session and by the helper for an RDP session. Windows only accepts it when the setting Disable or enable software Secure Attention Sequence (SoftwareSASGeneration) allows services: when no policy configures it, the agent sets it to Services (1) while it is installed (Windows ignores a value switched on only for a moment) and uninstalling removes it again; a configured policy is respected (the tab says so if it doesn't allow it). Each press is logged with the session and the setting.
• Virtual display (servers without a monitor): a GPU without a monitor often offers only 640×480. With the install option Virtual display for servers without a monitor (on by default; MSI property VIRTUALDISPLAY=1|0, or the .rhagent file) the agent installs a virtual monitor driver and switches it on while a desktop connection needs it: at the size of the RemoteHub window, as the primary monitor; it follows the window's size and is switched off when the last connection ends. virtualDisplay in agent.json: auto (default – only when the device offers no usable resolution), always, off.
  • The driver is the open-source Virtual Display Driver (MIT, an Indirect Display Driver, signed by SignPath Foundation), shipped unchanged in third-party\VirtualDisplayDriver and checked by hash before it is installed. For a silent install the device trusts SignPath Foundation as a driver publisher (Trusted Publishers); unchecking the option or uninstalling the agent removes the driver, the device and that trust again (the trust only if the agent added it).
• Audit: the agent's log records who connected from where, to which session, how (consent, view-only) and for how long – never screen content or keystrokes. The same entries go to the Windows Application log, source RemoteHub Agent (for event forwarding, Intune or a SIEM):
  • Information: 1000/1001 PowerShell session started/ended, 1100/1101 remote desktop started/ended, 1102 the user who signed in or unlocked allowed it, 1103 continued after a dropped connection.
  • Warning: 2000 sign-in refused, 2100 remote desktop refused, 2101 the user who signed in or unlocked refused it, 2102 ended for no input.
  • Error: 3100 remote desktop error.
• Not yet: signing in automatically with stored credentials (on the backlog), audio, file drag and drop into the picture, a relay for devices outside the network.

Jump hosts (devices RemoteHub can't reach directly)

• Use it: drag a connection (or a folder) onto the middle of another connection – or right-click → Move under – and it is reached through that connection's RemoteHub Agent. The jump host shows them below its shares; each shows via JUMP01 next to its address. Move it out again (drag it into a folder, or Move under → Out of JUMP01) and it connects directly. Nothing else to set: the navigation is the route.
• What goes through: RDP, PowerShell remoting (WinRM), the RemoteHub Agent (remote desktop, PowerShell, files, registry, services, processes) and network shares – SMB, SFTP and WebDAV, a server's shares and shares on their own placed below a jump host (or in a folder under it). FTP doesn't (its data connections go to addresses the server announces; its menu entries say so). One hop: a connection below a jump host can't be a jump host itself.
• Network shares through a jump host: SMB always uses RemoteHub's own SMB client there (Windows' client only connects to port 445, and that port on this PC is its own server) – NTLM sign-in, no Kerberos. SFTP host keys and WebDAV certificates are checked against the share's own name, as for a direct connection. The tab shows via JUMP01 after the connection type.
• RDP through a jump host: the RDP client connects to a local port on this PC that only RemoteHub itself may use, and it can't check the server's certificate by name there. RemoteHub checks it first: a certificate this PC trusts for the name is fine; otherwise you confirm it once (its thumbprint, and how to show it on the device), and RemoteHub connects without asking until it changes. Sign-in uses NTLM (Kerberos needs the real name); where NTLM is blocked, use the remote desktop through the agent.
• PowerShell remoting through a jump host needs HTTPS (WinRM only sends a password over HTTP to trusted hosts, and 127.0.0.1 isn't one unless you add it). Set up PowerShell remoting on the target fills in the jump host's address and fetches the certificate through it. A device with the agent installed uses the agent unless the connection itself is set to PowerShell remoting.
• Signing in: RemoteHub signs in to the jump host's agent with the jump host's credentials and to the device with the device's own – the device's credentials are inherited from the jump host's folders, never from the jump host itself. A password that isn't stored is asked once and kept in memory.
• Installing the agent on a device behind a jump host: silently over PowerShell remoting through the jump host when that works, otherwise Install RemoteHub Agent… → Save the installer and the enrollment file to a folder and install them there by hand or with software distribution. The firewall scope can be set to the jump host's address in that network (Add JUMP01 (…)). Updates go through the jump host.
• Security: the jump host only relays bytes – TLS to the device's pinned certificate runs end to end, so it never sees the device's credentials, the picture or the commands. RemoteHub keeps one signed-in connection per jump host for all tabs and closes it after 2 minutes without use.
• Policy on the jump host (same key as above):
  • TunnelEnabled (DWORD 0): this device is never a jump host.
  • TunnelTargets (REG_MULTI_SZ): where it may connect to – address ranges (10.20.0.0/16, fd00::/8, 10.1.2.3) and names (sql01.contoso.local, *.contoso.local). Unset: anywhere. The jump host's own addresses are refused unless an entry names that exact address; loopback, link-local (169.254.0.0/16, e.g. cloud metadata) and multicast addresses unless a range of /8 or narrower contains them (0.0.0.0/0 doesn't). A name allowed by pattern that resolves there is refused too.
  • TunnelPorts (REG_MULTI_SZ): ports it may connect to (58732, 3389, 5985-5986, *). Unset: every port.
  • MaxTunnelStreams (DWORD, 1–1024, default 64): connections open at once through one jump connection.
  • Right Tunnel (subkey Rights): who may use it as a jump host – by default the agent's allowed groups (Administrators).
• Audit on the jump host: 1200/1202 jump connection started/ended (account, source), 1201 each connection through it (target, address, port, duration, bytes), 2200 refused by policy (which rule).

Storage & security

Choose the location under Settings → Security & storage → Change location…. The current location is shown at the bottom of the connection list.

Mode	File	Encryption
This PC (default)	%LOCALAPPDATA%\RemoteHub\remotehub.db	An encrypted SQLite database (see below). Its key is protected with Windows DPAPI for your user account (and the startup protection, if on). No password, but only you on this PC can read it.
Shared folder (OneDrive, network share)	<folder>\RemoteHub.settings	AES-256-GCM with a password (PBKDF2-SHA256, 600k iterations). The password is asked once per PC; after that the derived key is remembered on that PC (DPAPI-protected, keys.dat). Use it to sync between your PCs or to share connections with other admins.

• The local database (since 0.14; before, %APPDATA%\RemoteHub\settings.dat):
  • Whole-file encryption with SQLite3 Multiple Ciphers, ChaCha20-Poly1305: every page is encrypted and authenticated – also the indexes and the write-ahead log. A changed page fails to read instead of returning wrong data. The key is random (256 bit), kept in db.key next to the database, protected like the startup protection describes.
  • Passwords are encrypted a second time, field by field (AES-256-GCM with a separate key, bound to their record), so they never appear in the records themselves.
  • Only what changed is written – no more rewriting one big file on every change.
  • Moved automatically: on the first start of 0.14, settings.dat is copied into the database, read back and compared field by field. Only then is it renamed to settings.dat.migrated (still encrypted as before, deleted after 30 days). If anything differs, settings.dat stays in use and nothing is lost. Older versions don't read the database.
  • Daily check and backup: at start (once a day) every page is checked and the database copied to backup\ (same encryption, the last 7 kept). If the database can't be opened, RemoteHub offers the latest backup; the damaged file is kept beside it.
  • Local only – never in OneDrive or on a network share (SQLite files corrupt there). The shared-folder mode below still uses its own file.
• Audit log (Settings → Logs → Open audit log…, or right-click a connection → Audit log…): what happened in RemoteHub on this PC – sessions (connected, disconnected with duration, failed), connections, folders, saved credentials and settings added, changed (which fields – never values) or deleted, copied passwords, file transfers, recordings, agent installs, backups, unlocking and the storage itself. Never passwords, clipboard or file contents.
  • Filter by period, kind of event, text and connection; for one connection it also shows how many sessions and how long in total. Export CSV… (values a spreadsheet would run as a formula are defused).
  • Append-only: the database rejects changes to entries and deletes inside the retention period. Each entry includes the hash of the one before (hash chain); Verify integrity finds a changed, removed or inserted entry. This makes changes detectable, not impossible, for someone who holds your Windows account's key – a tamper-proof log needs a central server.
  • Entries are kept 365 days by default – Settings → Logs → Keep entries for (30 days to 10 years; older entries are removed when RemoteHub starts), or the policy AuditRetentionDays, which wins. The RemoteHub Agent writes its own audit to the device's Windows Event Log.
• Sync conflicts: when the shared file is changed on another PC, RemoteHub notices it and offers to reload. If both sides changed it, you choose Reload (take theirs) or Keep mine. Nothing is overwritten silently.
• Shared file unavailable at start (not synced yet, offline, password cancelled): the app starts with this PC's settings and doesn't touch the shared file. Restart to try again.
• Dark theme is the default (Settings → General → Theme to change). Window layout, theme and switch keys are per PC (%APPDATA%\RemoteHub\local.json) and don't sync.
• Preset by IT (Intune / GPO): registry value SettingsFolder (REG_SZ or REG_EXPAND_SZ) under HKLM\SOFTWARE\Policies\RemoteHub or HKCU\SOFTWARE\Policies\RemoteHub, e.g. %OneDriveCommercial%\RemoteHub. Users can't change the location while the policy is set.
• Forget remembered passwords on this PC (in the same dialog) removes the cached keys.
• Export / import backup (Menu): portable, password-protected file (AES-256-GCM, PBKDF2-SHA256 with 600k iterations), including saved credentials. You can restore it on any PC or user account, either as a new folder or by replacing everything.
• The single-instance pipe only accepts connections from the same Windows user (PipeOptions.CurrentUserOnly).
• The RDPMANAGER_DATA_DIR environment variable points the app at a different local data folder, which is useful for testing.

License

Copyright (C) 2026 Grischa Ernst.

RemoteHub and the RemoteHub Agent are free software: you can redistribute and/or modify them under the terms of the GNU Affero General Public License, version 3 (AGPL-3.0-only), as published by the Free Software Foundation – see LICENSE. They are distributed in the hope that they will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose.

• The AGPL also covers use over a network: if you run a modified version that people use remotely, you must offer them its source code.
• The libraries and the driver shipped with RemoteHub keep their own licenses – see THIRD-PARTY-NOTICES.md.
• Both files are installed next to RemoteHub.exe and RemoteHubAgent.exe (LICENSE.txt), and RemoteHub shows them under Settings → Help & about.

Contributing

Contributions are welcome – see CONTRIBUTING.md. Before a first pull request is merged, contributors agree to the Contributor License Agreement with a comment in the pull request: they keep the copyright to their work and allow the project to license it under other terms too (for example a commercial license), so RemoteHub can offer one later. Security problems: SECURITY.md.