Buggy sliders on macos when throttling

[shunlog]

Hi, thanks for the nice lib!

I noticed that sliders on macos are buggy when throttling is involved.
It works fine on windows and linux however.

Here is a demo:

2025-08-12.14-52-16.mp4

#lang racket/base

(require racket/gui/easy
         racket/gui/easy/operator)

(define @a (@ 0))
(define @b (@ 0))
(define @b2 (obs-throttle @b))

(render
 (window
  (hpanel
   (text "Slider on @a")
   (slider @a #:min-value 0 #:max-value 100
           (λ (v) (:= @a v)))
   (text (obs-map @a number->string)))

  (hpanel
   (text "Slider on @b")
   (slider @b #:min-value 0 #:max-value 100
           (λ (v) (:= @b v)))
   (text (obs-map @b number->string))
   (text (obs-map @b2 number->string)))
  
  (hpanel
   (text "Slider on throttled @b")
   (slider @b2 #:min-value 0 #:max-value 100
           (λ (v) (:= @b v)))
   (text (obs-map @b number->string))
   (text (obs-map @b2 number->string)))
  ))

When the slider value is the throttled observable, there is only 1 bug: the observable value is not updated during sliding.

On the other hand, when the slider value is the original observable, there is one additional bug: the value is set to where the cursor started sliding.

[shunlog]

Creating a throttled observer for @a with (define @a2 (obs-throttle @a)) makes the first slider buggy as well, even though @a2 is not used anywhere (which is a bit surprising)

[Bogdanp]

The example appears to work correctly on macOS at first glance and your video seems to be on Linux. Is the issue actually on Linux, not macOS?

[Bogdanp]

EDIT: Nope, turns out the below is wrong, too. The third slider's callback doesn't actually run on programmatic change. So, I'll have to dig in more, later.

Oh, OK I see it now. I'm not sure this is a bug in the library. The issue is the fact that your third slider is also updating @b, so you can end up in a situation where a throttled update completes (a) while you're moving the slider (b) and the callback runs to update @b (c), so you can end up with the following orderings:

• a, b, c (one issue in the video)
• a, c, b (another issue in the video)
• b, a, c (issue not noticeable)

There are more orderings, but these are the 3 broad classes, I think. To work around the issue, I would probably do something along these lines:

#lang racket/base

(require racket/gui/easy
         racket/gui/easy/operator)

(define t current-inexact-monotonic-milliseconds)

(define @a (@ 0))
(define @b (@ (cons (t) 0)))
(define @c (@ (cons (t) 0)))
(define @b2
  (obs-combine
   (lambda (b2 c)
     (car (sort (list b2 c) > #:key car)))
   (obs-throttle @b)
   @c))

(define @b-num (~> @b cdr))
(define @c-num (~> @c cdr))
(define @b2-num (~> @b2 cdr))

(render
 (window
  (hpanel
   (text "Slider on @a")
   (slider @a #:min-value 0 #:max-value 100
           (λ (v) (:= @a v)))
   (text (obs-map @a number->string)))

  (hpanel
   (text "Slider on @b")
   (slider @b-num #:min-value 0 #:max-value 100
           (λ (v) (:= @b (cons (t) v))))
   (text (obs-map @b-num number->string))
   (text (obs-map @c-num number->string)))

  (hpanel
   (text "Slider on throttled @b")
   (slider @b2-num #:min-value 0 #:max-value 100
           (λ (v) (:= @c (cons (t) v))))
   (text (obs-map @b-num number->string))
   (text (obs-map @c-num number->string)))))

It's not great, so maybe it would make sense for us to add an obs-latest combinator.

[Bogdanp]

Hi @shunlog, would you mind giving the latest version a try and let me know if you still have this problem?

[shunlog]

The second bug is fixed: now the second slider's value is not reset to where the sliding action started. However, the first bug is still there: the value of the observable is not being updated live during sliding.

[Bogdanp]

The second bug is fixed: now the second slider's value is not reset to where the sliding action started. However, the first bug is still there: the value of the observable is not being updated live during sliding.

Thanks for checking! I've pushed another change that should at least make the first bug better most of the time.

[shunlog]

Ok, but shouldn't the issue be reopened because of the second bug that's still there? I can do a comparison on macos and linux to make the issue clear

[shunlog]

Macos (I'll upload linux later):

2025-08-26.16-19-39.mp4

#lang racket/base

(require racket/gui/easy
         racket/gui/easy/operator)

(define @a (@ 0))
(define @b (@ 0))
(define @b2 (obs-throttle @b))

(render
 (window
  (hpanel
   (text "Slider on @a")
   (slider @a #:min-value 0 #:max-value 100
           (λ (v) (:= @a v)))
   (text "@a:")
   (text (obs-map @a number->string)))
  (hpanel
   (text "Slider on @b")
   (slider @b #:min-value 0 #:max-value 100
           (λ (v) (:= @b v)))
   (text "@b:")
   (text (obs-map @b number->string))
   )
  (hpanel
   (text "Slider on @b2")
   (slider @b2 #:min-value 0 #:max-value 100
           (λ (v) (:= @b v)))
   (text "@b2:")
   (text (obs-map @b2 number->string)))))

[Bogdanp]

I think I've lost track of what the issue is or don't quite follow since your latest macOS video looks right to me. I'll wait for the Linux video to compare.

[shunlog]

Linux:

demo-2025-08-26_21.04.46.mp4

[shunlog]

I see following differences on macOS, all of which are unexpected (on Linux everything works as expected):

1. while moving the slider for @b, the value of @b2 and of its slider are not updated
2. while moving the slider @b2, the value of @b2 is not updated, only after releasing it

As I understand, there are two kinds of events that a slider emits as "updates": continuously while it is being dragged, and once after you release the mouse button. That's why I find the throttling useful: it helps limit how often the slider triggers a callback while being dragged

[Bogdanp]

Thanks for the video, I had assumed that the behavior would be the same between all platforms (i.e. that Racket threads would be suspended during sliding).

This is, unfortunately, an issue with racket/gui on macOS, as you can see by running this example:

#lang racket/gui

(define f
  (new frame%
       [label "Test"]))

(define thd
  (thread
   (lambda ()
     (let loop ()
       (println `(value ,(thread-receive)))
       (loop)))))

(define tick-thd
  (thread
   (lambda ()
     (let loop ()
       (println 'tick)
       (sleep 1)
       (loop)))))

(define timer
  (new timer%
       [notify-callback
        (lambda ()
          (println 'timer-tick))]
       [interval 1000]))

(define s
  (new slider%
       [parent f]
       [label "Test"]
       [init-value 0]
       [min-value 0]
       [max-value 100]
       [callback (lambda (self _event)
                   #;(println `(value ,(send self get-value)))
                   (sleep)
                   (thread-send thd (send self get-value)))]))

(send f show #t)

None of the Racket threads, nor the timer% run while sliding.

I'll open an issue in racket/gui.