RustDesk MouseMux Compliant Edition

Latest revision: October 2025

Multi-Cursor Remote Desktop

The RustDesk MouseMux Compliant Edition enables multiple remote users to connect to the same desktop, each with their own cursor, keyboard, and the ability to interact simultaneously in real-time. The key feature: your clients don’t need to change a thing. Anyone with standard RustDesk (whether they’re using Windows, macOS, Linux, or even a mobile device) can connect to your MouseMux-enabled Windows host and get their own cursor. No special software on the client side. No reinstallation. No configuration.

About RustDesk

RustDesk is an open-source remote desktop platform written in Rust for both performance and security. It offers an alternative to commercial solutions like TeamViewer or AnyDesk, offering end-to-end encryption, cross-platform support across every major operating system, and the freedom to self-host your own server for complete data control. Perhaps most importantly, it’s completely free with no licensing restrictions, no connection limits, and full commercial use allowed under the GPL-3.0 license. For organizations requiring professional support, commercial support options are available at https://rustdesk.com/pricing.

RustDesk has low latency for responsive remote sessions. It supports hardware acceleration, adapts to network conditions automatically, and includes modern features like file transfer, clipboard synchronization, audio forwarding, and multi-monitor support. For enterprises and privacy-conscious users, the ability to self-host means your data never touches third-party servers. For developers, the fully open-source codebase provides transparency and the freedom to audit or modify as needed.

Our MouseMux-specific modifications to RustDesk are also fully open source, available under the same GPL-3.0 license. All changes we’ve made to enable multi-cursor functionality are publicly available on GitHub at https://github.com/MouseMux/rustdesk for inspection, contribution, and community improvement. We believe in maintaining the open-source spirit of the original project while extending it to enable new collaborative possibilities.

The MouseMux Integration

The integration works like this: to enable multi-cursor functionality, you only need to run the RustDesk MouseMux Compliant Edition on the host machine. This modified version integrates with MouseMux to enable multi-cursor functionality, but to connecting clients, it appears as a completely normal RustDesk server. Your colleagues can use their existing RustDesk installations (downloaded straight from rustdesk.com) on whatever platform they prefer, and the moment they connect to your MouseMux-enabled host, they automatically receive their own independent cursor. You can even keep your normal RustDesk installed alongside the MouseMux edition and use whichever you need.

This backward compatibility means you can set up a collaborative workspace without requiring everyone on your team to install special software. A developer on macOS, a designer on Windows, and a manager on Linux can all connect using standard RustDesk clients, and each person immediately gets their own cursor with full interaction capabilities. The Windows host handles all the complexity behind the scenes, translating each client’s input into a separate MouseMux user while maintaining complete RustDesk protocol compatibility.

The technical implementation preserves user identity through the remote connection by tagging input from each client with a unique identifier. When RustDesk on the host receives these tagged inputs, it delivers them to MouseMux, which creates or assigns a cursor for each remote user. The complete desktop state (including all cursors, annotations, and user activity indicators) is then streamed back to every connected client. This bidirectional synchronization happens in real-time, creating the illusion that everyone is sitting at the same physical machine.

This comes bundled with MouseMux starting from version 2.1.80, so there’s no separate installation to manage. Simply click on the RustDesk app in the MouseMux app launcher, and you’re ready to accept multi-cursor remote connections.

What This Enables

When you combine MouseMux’s multi-cursor capabilities with remote desktop access, new interaction patterns are possible. These patterns simply don’t exist in traditional single-cursor remote desktop solutions.

Collaborative Drawing and Annotation. MouseMux includes a drawing mode that lets users annotate the screen with colored markers. Enable this during a remote session, and every connected user can annotate. Picture a design review where five people simultaneously circle issues, draw arrows to highlight problems, and sketch suggested improvements. Each uses their own cursor with their own color. This works over any application because the annotations are rendered as an overlay. Architecture reviews, code reviews, teaching sessions, brainstorming. Anywhere visual communication matters, multi-cursor annotation changes team collaboration. Clear everything with a single hotkey (ALT-F5) and start fresh.

Device Transformation. MouseMux allows any input device to behave as any other input type. A mouse can send pen device events, or output touch events instead of mouse clicks. This flexibility is useful when combined with remote access. A QA engineer testing a drawing application remotely can configure their mouse to send pen events, verifying that pen input is recognized and handled correctly without shipping specialized hardware. Teams developing touch-based interfaces can simulate multi-touch gestures by having multiple remote users act as different “fingers,” all on a standard desktop without touch screens. One user might configure their input for precision CAD work while another optimizes for fast navigation. Each person’s interaction style is preserved across the remote connection.

Macro System. MouseMux can record complex sequences of mouse movements, clicks, and keystrokes, then play them back on demand. Combine this with remote users and device transformation, and you can record a UI test sequence, send it to a remote tester, and have it replayed on their cursor (but configured to output as touch input instead of mouse input). Testing touch interfaces remotely without touch screens becomes straightforward. Training scenarios can leverage macros as well: instructors record demonstrations showing complex procedures, and remote students watch the macro play on one cursor while following along with their own, rewinding and replaying sections as needed.

Cursor Replication. MouseMux’s cursor replication feature creates shadow cursors that mirror a primary cursor’s movements. In a remote setting, this enables distributed replication where one user’s actions replicate across multiple windows or application instances. QA workflows can run in parallel. Test the same interaction across different software versions simultaneously. Training can be more effective when students can “shadow” an expert’s cursor movements, seeing exactly where to click and how to navigate.

Multi-Keyboard Interaction. Each remote user can pair a keyboard with their cursor, creating independent input contexts. Two developers can simultaneously work on the same codebase. One writes code in the IDE while another writes tests in a different window. Both work in real-time, both fully active. Technical writers can document features while developers implement them, each seeing the other’s progress. Industrial control rooms can have multiple remote operators managing different subsystems, each with their own cursor and keyboard, all with full audit trails via MouseMux’s telemetry system. Even creative applications open up: digital artists collaborating on the same canvas from different locations, one sketching while another colors; music producers working different tracks in the same DAW, one adjusting effects while another arranges sequences.

All MouseMux Modes Work Remotely

MouseMux offers three distinct interaction modes, and all three work over RustDesk connections:

• Standard Mode acts like a normal shared Windows cursor. Just like traditional RustDesk where everyone controls the same cursor. Even in this mode, you can still see who is interacting through the MouseMux main UI, which shows each remote user’s name, cursor position, and activity status.

• Switched Mode gives each remote person their own cursor with turn-taking for window focus. Cursors take turns controlling whichever window is active, preventing conflicts when multiple people try to interact with the same application.

• Multiplex Mode enables full simultaneous interaction with intelligent conflict resolution, giving everyone their own cursor and allowing true concurrent access where everyone can work in different windows or even the same window with MouseMux managing who controls what.

Each remote user inherits MouseMux’s extensive per-device configuration capabilities. Custom acceleration curves, button remapping, scroll wheel behavior, cursor themes and colors, device type transformation. Everything that makes MouseMux powerful for local multi-user scenarios works identically for remote users. Activity indicators show who’s typing or clicking. User presence awareness makes it clear who’s connected and active. Color-coded cursors prevent confusion about who’s doing what. Remote users can independently drag and resize windows, lock their cursor to specific monitors in multi-monitor setups, and utilize cursor mirroring for specialized workflows. The system supports hot-plugging, so remote users can connect or disconnect at any time without disrupting others.

Real-World Applications

Remote IT Support. We’ve all been there: a friend connects remotely to help fix something on your computer. You know where the problem is and try to click there, but they’re also trying to navigate. The cursor jumps around as you both pause, unsure who’s driving. “Are you moving it or am I?” With the RustDesk MouseMux Compliant Edition, this awkwardness disappears. Each person gets their own cursor, clearly labeled and color-coded. You can point to the problem while your friend investigates. MouseMux’s Switched Mode makes it clear who has control at any moment, preventing conflicts when you both interact with the same window.

Distributed Pair Programming. Multiple developers across different time zones connect to a shared development environment, each with their own cursor and keyboard. They can simultaneously work on different files, review code together, write tests in parallel, or debug collaboratively. All in real-time. One developer might configure their mouse as a “pen” to annotate code with drawings explaining complex logic while another refactors adjacent sections. The traditional “driver and navigator” model dissolves; everyone becomes a driver when they need to be.

Education. An instructor shares their desktop while students connect remotely, but unlike traditional screen sharing where students passively observe, each student can interact using their own cursor. They can click links, try exercises, annotate their questions directly on the shared screen, or highlight areas where they’re confused. The instructor maintains control but students aren’t passive. They’re active participants in the learning process.

Design Reviews. Design teams conducting remote reviews can have everyone annotate simultaneously. One person circles layout issues, another draws suggested improvements, someone else highlights what works well. All visible to everyone in real-time, all layered over the actual design files. No more “can you see my cursor?”. Everyone’s cursor is always visible.

Industrial Control Systems. Multiple operators connect to SCADA systems or control panels remotely, each managing different subsystems with their own cursor. MouseMux’s telemetry system tracks every action by every user, creating complete audit trails for compliance and security. Supervisors can connect to oversee operations, intervening when necessary with their own cursor while operators continue their work.

Customer Support. Both support agents and supervisors can connect simultaneously. The agent works on fixing the customer’s issue while the supervisor provides guidance via annotations or takes over specific actions when needed, all without disconnecting the agent or creating confusion about who’s doing what.

Security, Performance, and Requirements

The MouseMux Compliant Edition maintains all of RustDesk’s security features without compromise. End-to-end encryption protects all connections using modern cryptographic standards. Self-hosted server options keep data completely under your control, never touching third-party infrastructure. Optional two-factor authentication adds another security layer. For regulated industries, MouseMux’s industrial edition provides complete accountability. Every action is logged with clear attribution to specific remote users, creating audit trails that meet compliance requirements.

Performance: - Base RustDesk stream: 2-5 Mbps bandwidth - Each additional remote user: +1-2 Mbps - Maximum users: Up to 196 (recommended: under 10 for optimal performance) - CPU overhead: 2-5% per remote user - Latency: 10-30ms (LAN), 50-150ms (internet)

Host Requirements: - Windows 11, 10, 8, 7, or XP - MouseMux version 2.1.80 or higher - Modern multi-core processor - 5-20 Mbps upload bandwidth - Wired network connection recommended

Client Requirements: - Any OS supported by RustDesk (Windows, macOS, Linux, iOS, Android) - Standard RustDesk client from rustdesk.com - 2-10 Mbps download bandwidth

Getting Started

1. Update MouseMux to version 2.1.80 or later
2. Click on the RustDesk app in the MouseMux app launcher
3. Note the connection ID displayed
4. Remote users connect using standard RustDesk clients from rustdesk.com
5. Each connection automatically receives its own cursor

MouseMux handles all the complexity behind the scenes, requiring minimal configuration. It just works.

The Bigger Picture

Remote desktop has existed for decades, but it has always been fundamentally single-user. One person controls while others watch. This limitation has shaped how we think about remote collaboration. We’ve built entire workflows around “taking turns” and “passing control.” These workflows feel unnatural because they are. They’re workarounds for a technical limitation we’ve simply accepted.

The RustDesk MouseMux Compliant Edition changes this. Multiple cursors enable more natural remote collaboration than traditional single-cursor solutions.

Whether you’re pair programming across continents, teaching students remotely, managing industrial systems, or simply helping a friend troubleshoot their computer while both of you can click and point. This enables new workflows. And because standard RustDesk clients work without modification, you can start collaborating this way today, with the tools people already have installed.

RustDesk is an open-source project licensed under GPL-3.0. The MouseMux Compliant Edition is a derivative work created to enable multi-cursor remote desktop functionality. We maintain compatibility with upstream RustDesk and contribute improvements back to the community where possible.