UltraVNC

Pros of TigerVNC

• Cross-platform support (Windows, macOS, Linux)
• Better performance and image quality
• Active development and regular updates

Cons of TigerVNC

• Lacks some advanced features found in UltraVNC
• May require more setup and configuration

Code Comparison

TigerVNC (C++):

rfb::Region2D updateRegion;
updateRegion.assign_union(damage);
writer()->writeFramebufferUpdate(updateRegion, encodings);

UltraVNC (C++):

rfb::Region2D updateRegion;
updateRegion.assign_union(m_damage);
m_encoder->writeRect(updateRegion, m_encodings);

Both projects use similar approaches for handling framebuffer updates, but TigerVNC's code appears to be more streamlined and modern. TigerVNC also tends to have more consistent coding style and better documentation throughout its codebase.

TigerVNC is generally considered more suitable for cross-platform use and offers better performance, while UltraVNC provides some unique features specific to Windows environments. The choice between the two depends on the specific requirements of your project and the target platforms.

Pros of libvncserver

• Cross-platform support for multiple operating systems
• Extensive documentation and active community support
• Flexible and modular architecture for easier customization

Cons of libvncserver

• Potentially steeper learning curve for beginners
• May require more setup and configuration compared to UltraVNC

Code Comparison

UltraVNC (C++):

void ClientConnection::SendRFBMsg(rfbClientToServerMsg msg, UINT nLen)
{
    if (m_socket != NULL)
        m_socket->SendExact((char *)&msg, nLen);
}

libvncserver (C):

rfbBool rfbSendFramebufferUpdate(rfbClientPtr cl, sraRegionPtr updateRegion)
{
    rfbFramebufferUpdateMsg *fu = (rfbFramebufferUpdateMsg *)cl->updateBuf;
    fu->type = rfbFramebufferUpdate;
    fu->nRects = 0;
    return TRUE;
}

Both repositories provide VNC (Virtual Network Computing) functionality, but they differ in implementation and target use cases. UltraVNC is primarily focused on Windows systems, while libvncserver offers broader platform support. UltraVNC may be easier for Windows-specific deployments, while libvncserver provides more flexibility for cross-platform development.

Pros of droidVNC-NG

• Specifically designed for Android devices, offering better mobile compatibility
• More recent development and updates, potentially including newer features
• Lightweight and optimized for mobile performance

Cons of droidVNC-NG

• Limited to Android platform, less versatile than UltraVNC
• Smaller community and potentially less documentation
• May lack some advanced features present in UltraVNC

Code Comparison

UltraVNC (C++):

void ClientConnection::ReadExact(char *inbuf, int wanted)
{
    int offset = 0;
    while (wanted > 0) {
        // ... (connection handling code)
    }
}

droidVNC-NG (Java):

private void readFully(InputStream is, byte[] b, int off, int len) throws IOException {
    while (len > 0) {
        int count = is.read(b, off, len);
        // ... (error handling and offset adjustment)
    }
}

Both projects implement similar functionality for reading data from a connection, but use different languages and slightly different approaches suited to their respective platforms.

Pros of noVNC

• Browser-based, no client installation required
• Cross-platform compatibility (works on any device with a modern web browser)
• Easy integration with web applications and cloud environments

Cons of noVNC

• Potentially higher latency due to web-based nature
• May have limited support for advanced features compared to native VNC clients

Code Comparison

noVNC (JavaScript):

var rfb = new RFB(document.getElementById('screen'), 'ws://example.com:5900');
rfb.scaleViewport = true;
rfb.resizeSession = true;

UltraVNC (C++):

VNCViewer viewer;
viewer.Connect("example.com", 5900);
viewer.SetScalingMode(SCALING_ASPECT_FIT);

Key Differences

• Implementation: noVNC is primarily JavaScript-based, while UltraVNC is written in C++
• Deployment: noVNC runs in web browsers, UltraVNC requires a native client installation
• Use cases: noVNC is ideal for web-based remote access scenarios, UltraVNC is better suited for traditional desktop environments

Conclusion

Choose noVNC for web-based, cross-platform remote access with easy integration. Opt for UltraVNC when native performance and advanced features are priorities in desktop environments.

Pros of FreeRDP

• Cross-platform support (Windows, macOS, Linux, iOS, Android)
• Implements the Remote Desktop Protocol (RDP), which is widely used in Windows environments
• Active development with frequent updates and bug fixes

Cons of FreeRDP

• Primarily focused on RDP, limiting its use for other remote desktop protocols
• May have a steeper learning curve for users unfamiliar with RDP

Code Comparison

FreeRDP (C):

BOOL freerdp_connect(freerdp* instance)
{
    rdpContext* context;
    BOOL status = TRUE;
    // ... (connection logic)
}

UltraVNC (C++):

bool ClientConnection::Connect()
{
    vnclog.Print(3, _T("Connecting to %s port %d\n"), m_host, m_port);
    // ... (connection logic)
}

Both projects use C-based languages, with FreeRDP primarily using C and UltraVNC using C++. FreeRDP's codebase tends to be more modular and structured, while UltraVNC's code is more focused on the VNC protocol implementation.

FreeRDP is better suited for environments where RDP is the primary protocol, especially in Windows-centric networks. UltraVNC, on the other hand, is ideal for users who specifically need VNC support and prefer a lightweight, VNC-focused solution.