when possible, it's good practice to encase your transformations in a pushMatrix(), popMatrix().

Actually, the way you show it, it won't do anything! the image() calls must be before the popMatrix()...
I am suspecting more a thread issue with GTimer, that's why I moved the topic to Contributed Libraries.

Thanks for the answers. PhiLho was right. I moved my code to draw() and adjusted the frameRate and now everything works fine. Thanks for your time. Best, d

The GTimer is used to call a method/function on a fixed time interval. It should not be used for drawing to the screen rather it should be used to update values stored in variables e.g. currentPosition which can then be used inside the draw method.

Thanks quarks,

So the way to go is only using draw for actually displaying stuff? The timing is a bit unclear for draw() I think, with the frameRate function. Is there a clearer way to manage how often things are drawn to the screen?

TIA, best, d

The timing is a bit unclear for draw() I think, with the frameRate function.

The frameRate function is not a good way to control animation speed because the actual frame rate will vary as the sketch runs.

When creating animations the main priority is to make the animation speed independent of the frame rate. For simple animations there are two possible techniques.

TECHNIQUE 1 - Use a timer to create events at constant time intervals.
The generated events are used to call a method that updates any variables used to control the animation but does not perform any drawing tasks. In most cases this will work fine provided the time intervals are not too small. The following code demonstrates this approach.

1. import g4p_controls.*; // Depends on version of G4P being used
2. 
   
3. GTimer timer;
4. float x, y;
5. float velX = 75; // pixels per second
6. 
   
7. public void setup(){
8.   size(400,200);
9.   fill(128,0,0);
10.   noStroke();
11.   x = 0;
12.   y = height/2;
13.   timer = new GTimer(this, this, "update", 20);
14.   timer.start();
15. }
16. 
    
17. public void draw(){
18.   background(200,255,200);
19.   ellipse(x,y,10,10);
20. }
21. 
    
22. public void update(GTimer timer) {
23.    x += (velX * timer.getInterval())/1000 ;
24. } 

TECHNIQUE 2 - Measure the time between frames and use this to control animation
This is the prefered method because it truly produces frame-rate independant animation. The following code does exactly the same as the timer example but uses the elapsed time between frames to control the position of the ball.

1. float x, y;
2. float velX = 75; // pixels per second
3. int ctime, ltime; // current and last frame times (milliseconds)
   
4. float etime;      // time between frames (seconds)
5. 
   
6. public void setup(){
7.   size(400,200);
8.   fill(128,0,0);
9.   noStroke();
10.   x = 0;
11.   y = height/2;
12.   ctime = ltime = millis();
13. }
14. 
    
15. public void draw(){
16.   // Get current time in milliseconds
17.   ctime = millis();
18.   // Calculate elapsed time in seconds
19.   etime = 0.001 * (ctime - ltime);
20.   // Reset last time ready for next draw
21.   ltime = ctime;
22.   // Move x by velocity * elapsed time
23.   x += velX * etime;
24.  
25.   background(200,255,200);
26.   ellipse(x,y,10,10);
27. }

I've liked a lot technique 2. It goes to my personal online collection! 
I did some tiny tweaks as well. More constants & local variables and less field variables.
Check it out:

http://studio.processingtogether.com/sp/pad/export/ro.9jAqLpHlv-8K3/latest

/** 
 * Frame-Independant Animation (v2.0)
 * by Quarks (2013/Jul)
 * 
 * http://forum.processing.org/topic/scale-jumps-back-to-100
 * http://studio.processingtogether.com/sp/pad/export/ro.9jAqLpHlv-8K3/latest
 */

float x, y;
int lTime;

final static short VEL_X = 0200; // pixels per second
final static short DIM = 040, FPS = 60;
final static color BG = #C0F0C0, FG = #800000;

void setup() {
  size(400, 200);
  frameRate(FPS);
  fill(FG);
  noStroke();

  y = height >> 1;
  lTime = millis();
}

void draw() {
  // Get current time in milliseconds:
  final int cTime = millis();

  // Calculate elapsed time in seconds:
  final float eTime = 1e-3 * (cTime - lTime);

  // Reset last time ready for next draw:
  lTime = cTime;

  // Move x by velocity * elapsed time:
  x = (x + VEL_X*eTime) % width;

  background(BG);
  ellipse(x, y, 040, 040);
}

Wow, thanks for the replies! I was away but I'll try them out. Best, d