[linux] Changing the resolution of a VNC session in linux

I use VNC to connect to a Linux workstation at work. At work I have a 20" monitor that runs at 1600x1200, while at home I use my laptop with its resolution of 1440x900. If I set the vncserver to run at 1440x900 I miss out on a lot of space on my monitor, whereas if I set it to run at 1600x1200 it doesn't fit on the laptop's screen, and I have to scroll it all the time.

Is there any good way to resize a VNC session on the fly?

My VNC server is RealVNC E4.x (I don't remember the exact version) running on SuSE64.

Interestingly no one answered this. In TigerVNC, when you are logged into the session. Go to System > Preference > Display from the top menu bar ( I was using Cent OS as my remote Server). Click on the resolution drop down, there are various settings available including 1080p. Select the one that you like. It will change on the fly.

Make sure you Apply the new setting when a dialog is prompted. Otherwise it will revert back to the previous setting just like in Windows

I'm not sure about linux, but under windows, tightvnc will detect and adapt to resolution changes on the server.

So you should be able to VNC into the workstation, do the equivalent of right-click on desktop, properties, set resolution to whatever, and have your client vnc window resize itself accordingly.

On the other hand, if there's a way to move an existing window from one X-server to another, that might solve the problem.

I think you can use xmove to move windows between two separate x-servers. So if it works, this should at least give you a way to do what you want albeit not as easily as changing the resolution.

I think your best best is to run the VNC server with a different geometry on a different port. I would try based on the man page

$vncserver :0 -geometry 1600x1200
$vncserver :1 -geometry 1440x900

Then you can connect from work to one port and from home to another.

Edit: Then use xmove to move windows between the two x-servers.

I'm running TigerVNC on my Linux server, which has basic randr support. I just start vncserver without any -randr or multiple -geometry options.

When I run xrandr in a terminal, it displays all the available screen resolutions:

bash> xrandr
 SZ:    Pixels          Physical       Refresh
 0   1920 x 1200   ( 271mm x 203mm )   60
 1   1920 x 1080   ( 271mm x 203mm )   60
 2   1600 x 1200   ( 271mm x 203mm )   60
 3   1680 x 1050   ( 271mm x 203mm )   60
 4   1400 x 1050   ( 271mm x 203mm )   60
 5   1360 x 768    ( 271mm x 203mm )   60
 6   1280 x 1024   ( 271mm x 203mm )   60
 7   1280 x 960    ( 271mm x 203mm )   60
 8   1280 x 800    ( 271mm x 203mm )   60
 9   1280 x 720    ( 271mm x 203mm )   60
*10  1024 x 768    ( 271mm x 203mm )  *60
 11   800 x 600    ( 271mm x 203mm )   60
 12   640 x 480    ( 271mm x 203mm )   60
Current rotation - normal
Current reflection - none
Rotations possible - normal
Reflections possible - none

I can then easily switch to another resolution (f.e. switch to 1360x768):

bash> xrandr -s 5

I'm using TightVnc viewer as the client and it automatically adapts to the new resolution.

As far as I know there's no way to change the client's resolution just using VNC, as it is just a "monitor mirroring" application.

TightVNC however (which is a VNC client and server application) can resize the screen on the client side, i.e. making everything a little smaller (similar to image resizing techniques in graphics programs). That should work if you don't use too small font sizes. VNC should theoretically be compatible between different VNC applications.

Guys this is really simple.

login via ssh into your pi

execute

vncserver -geometry 1200x1600

This will generate a new session :1

connect with your vnc client at ipaddress:1

Thats it.

Solution by @omiday worked for me in Xvnc TigerVNC 1.1.0, so I condensed it into a single bash function vncsize x y. Use it like this: vncsize 1400 1000. It works for any VNC output name, "default" or "VNC-0".

function vncsize {
    local x=$1 y=$2
    local mode
    if mode=$(cvt "$x" "$y" 2>/dev/null)
    then
        if [[ $mode =~ "Modeline (.*)$" ]]
        then
            local newMode=${BASH_REMATCH[1]//\"/}
            local modeName=${newMode%% *}
            local newSize=( ${modeName//[\"x_]/ } )
            local screen=$(xrandr -q|grep connected|cut -d' ' -f1)
            xrandr --newmode $newMode
            xrandr --addmode "$screen" "$modeName"
            xrandr --size "${newSize[0]}x${newSize[1]}" &&
                return 0
        else
            echo "Unable to parse modeline for ($x $y) from $mode"
            return 2
        fi
    else
        echo "\`$x $y' is not a valid X Y pair"
        return 1
    fi
}

I think that depends on your window manager.

I'm a windows user, so this might be a wrong guess, but: Isn't there something called X-Server running on linux machines - at least on ones that might be interesting targets for VNC - that you can connect to with "X-Clients"?

VNC just takes everything that's on the screen and "tunnels it through your network". If I'm not totally wrong then the "X" protocol should give you the chance to use your client's desktop resolution.

Give X-Server on Wikipedia a try, that might give you a rough overview.

I have a simple idea, something like this:

#!/bin/sh

echo `xrandr --current | grep current | awk '{print $8}'` >> RES1
echo `xrandr --current | grep current | awk '{print $10}'` >> RES2
cat RES2 | sed -i 's/,//g' RES2

P1RES=$(cat RES1)
P2RES=$(cat RES2)
rm RES1 RES2
echo "$P1RES"'x'"$P2RES" >> RES
RES=$(cat RES)

# Play The Game

# Finish The Game with Lower Resolution

xrandr -s $RES

Well, I need a better solution for all display devices under Linux and Similars S.O

Perhaps the most ignorant answer I've posted but here goes: Use TigerVNC client/viewer and check 'Resize remote session to local window' under Screen tab of options.

I don't know what the $%#@ TigerVNC client tells remote vncserver or xrandr or Xvnc or gnome or ... but it resizes when I change the TigerVNC Client window.

My setup:

• Tiger VNC Server running on CentOS 6. Hosting GNOME desktop. (Works with RHEL 6.6 too)
• Windows some version with Tiger VNC Client.

With this the resolution changes to fit the size of the client window no matter what it is, and it's not zooming, it's actual resolution change (I can see the new resolution in xrandr output).

I tried all I could to add a new resolution to the xrandr, but to no avail, always end up with 'xrandr: Failed to get size of gamma for output default' error.

Versions with which it works for me right now (although I've not had issues with ANY versions in the past, I just install the latest using yum install gnome-* tigervnc-server and works fine):

OS: RHEL 6.6 (Santiago)
VNC Server:
Name        : tigervnc-server
Arch        : x86_64
Version     : 1.1.0
Release     : 16.el6

# May be this is relevant..
$ xrandr --version
xrandr program version       1.4.0
Server reports RandR version 1.4
$ 

# I start the server using vncserver -geometry 800x600
# Xvnc is started by vncserver with following args:
/usr/bin/Xvnc :1 -desktop plabb13.sgdcelab.sabre.com:1 (sg219898) -auth /login/sg219898/.Xauthority 
-geometry 800x600 -rfbwait 30000 -rfbauth /login/sg219898/.vnc/passwd -rfbport 5901 -fp catalogue:/e
tc/X11/fontpath.d -pn


# I'm running GNOME (installed using sudo yum install gnome-*)
Name        : gnome-desktop
Arch        : x86_64
Version     : 2.28.2
Release     : 11.el6

Name        : gnome-session
Arch        : x86_64
Version     : 2.28.0
Release     : 22.el6

Connect using Tiger 32-bit VNC Client v1.3.1 on Windows 7.

Found out that the vnc4server (4.1.1) shipped with Ubuntu (10.04) is patched to also support changing the resolution on the fly via xrandr. Unfortunately the feature was hard to find because it is undocumented. So here it is...

Start the server with multiple 'geometry' instances, like:

vnc4server -geometry 1280x1024 -geometry 800x600

From a terminal in a vncviewer (with: 'allow dymanic desktop resizing' enabled) use xrandr to view the available modes:

xrandr

to change the resulution, for example use:

xrandr -s 800x600

Thats it.

As this question comes up first on Google I thought I'd share a solution using TigerVNC which is the default these days.

xrandr allows selecting the display modes (a.k.a resolutions) however due to modelines being hard coded any additional modeline such as "2560x1600" or "1600x900" would need to be added into the code. I think the developers who wrote the code are much smarter and the hard coded list is just a sample of values. It leads to the conclusion that there must be a way to add custom modelines and man xrandr confirms it.

With that background if the goal is to share a VNC session between two computers with the above resolutions and assuming that the VNC server is the computer with the resolution of "1600x900":

1. Start a VNC session with a geometry matching the physical display:

   $ vncserver -geometry 1600x900 :1
   

2. On the "2560x1600" computer start the VNC viewer (I prefer Remmina) and connect to the remote VNC session:

   host:5901
   

3. Once inside the VNC session start up a terminal window.

4. Confirm that the new geometry is available in the VNC session:

   $ xrandr
   Screen 0: minimum 32 x 32, current 1600 x 900, maximum 32768 x 32768
   VNC-0 connected 1600x900+0+0 0mm x 0mm
      1600x900      60.00 +
      1920x1200     60.00  
      1920x1080     60.00  
      1600x1200     60.00  
      1680x1050     60.00  
      1400x1050     60.00  
      1360x768      60.00  
      1280x1024     60.00  
      1280x960      60.00  
      1280x800      60.00  
      1280x720      60.00  
      1024x768      60.00  
      800x600       60.00  
      640x480       60.00  
   

   and you'll notice the screen being quite small.

5. List the modeline (see xrandr article in ArchLinux wiki) for the "2560x1600" resolution:

   $ cvt 2560 1600
   # 2560x1600 59.99 Hz (CVT 4.10MA) hsync: 99.46 kHz; pclk: 348.50 MHz
   Modeline "2560x1600_60.00"  348.50  2560 2760 3032 3504  1600 1603 1609 1658 -hsync +vsync
   

   or if the monitor is old get the GTF timings:

   $ gtf 2560 1600 60
   # 2560x1600 @ 60.00 Hz (GTF) hsync: 99.36 kHz; pclk: 348.16 MHz
   Modeline "2560x1600_60.00"  348.16  2560 2752 3032 3504  1600 1601 1604 1656 -HSync +Vsync
   

6. Add the new modeline to the current VNC session:

   $ xrandr --newmode "2560x1600_60.00"  348.16  2560 2752 3032 3504  1600 1601 1604 1656 -HSync +Vsync
   

7. In the above xrandr output look for the display name on the second line:

   VNC-0 connected 1600x900+0+0 0mm x 0mm
   

8. Bind the new modeline to the current VNC virtual monitor:

   $ xrandr --addmode VNC-0 "2560x1600_60.00"
   

9. Use it:

   $ xrandr -s "2560x1600_60.00"
   

Adding to Nathan's (accepted) answer:

I wanted to cycle through the list of resolutions but didnt see anything for it:

function vncNextRes()
{
   xrandr -s $(($(xrandr | grep '^*'|sed 's@^\*\([0-9]*\).*$@\1@')+1)) > /dev/null 2>&1 || \
   xrandr -s 0
}

It gets the current index, steps to the next one and cycles back to 0 on error (i.e. end)

EDIT

Modified to match a later version of xrandr ("*" is on end of line and no leading resolution identifier).

function vncNextRes()
{
   xrandr -s $(($(xrandr 2>/dev/null | grep -n '\* *$'| sed 's@:.*@@')-2))  || \
   xrandr -s 0
}