"Fix" MacBook Neo Cursor Lag: Record 1 Pixel of the Screen Every 10 Seconds

https://gist.github.com/retroplasma/ec21767d0a8380c7ea9c2fbee1c7d6bf

by retroplasma • 29 days ago

229 105 29 days ago

gist.github.com

m132• 29 days ago

Steve turning in his grave

InsideOutSanta3• 29 days ago

Relevant quote from https://www.folklore.org/Shut_Up.html:

We showed [Gates] how the Macintosh mouse cursor moved smoothly, in a flicker-free fashion.

"What kind of hardware do you use to draw the cursor?", he asked. Many current personal computers had special hardware to draw small bitmaps called "sprites", and he thought we might be doing something similar.

Stitch4223• 29 days ago

This quote from 1981 stresses that taking away a responsive cursor is the most arrogant and disrespectful bug.

The audacity of developers to restart the discussion whether the mouse should follow user input induces rage on so many levels.

DonHopkins3• 29 days ago

SGIs and Suns had overlay planes just for that. In fact SGI 4Sight would draw the popup menus in the overlay plane, too, since reading back the color framebuffer to draw cursors or perform xor highlighting or restoring the background after popping down menus was extremely expensive with that hardware.

Sun's framebuffers with 8 bit color + 1 bit monochrome + 1 bit enable (like the cgfour / GX aka Lego graphics accelerator) put the cursor in the monochrome layer, and NeWS supported it as an overlay plane, an optimization of xor drawing and undrawing. The enable layer would switch between the color and monochrome layers on a per-pixel basis.

With NeWS, I could open up the enable and monochrome layers directly and draw into them with PostScript to perform temporary non-destructive highlighting, and make monochrome overlay windows that didn't damage the color windows underneath. But it was a bit of a hack (much uglier than this cursor lag fix). Here is a window subclass that lifts a monochrome window into the overlay plane so it doesn't damage color windows behind it:

https://donhopkins.com/home/archive/psiber/cyber/overlay.ps

  % Overlay plane compatibility hack for cg4 frame buffer.
  % This is a nebulous layer abstracted from a messy program, to make it run 
  % on generic NeWS servers. It should be rethought and rewritten. Repent!
  % 
  % Requires the devices /dev/cgfour0, /dev/cgfour0_ovl, and /dev/cgfour0_ove
  % (which can all be major 39 minor 0, or whatever), and the following patch 
  % to the NeWS 1.1 server sources (but X11/NeWS doesn't need to be patched!),
  % in order to take advantage of a cg4 under NeWS 1.1 (Otherwise it falls back
  % to using exclusive-or).

[...]

  % Damn damn damn! X11/NeWS Version 1.0 FCS on a cg4 can open up the
  % enable plane, but there's a bug that trashes the enable plane color map,
  % so we can draw in gray scales but we can't draw in white (black?).

The "Pseudo Scientific Visualizer" used it by making a PSVisualizerWindow subclass of OverlayWindow:

https://donhopkins.com/home/archive/psiber/cyber/mics.ps

And the popup pointing hand shaped callout window also used it so it didn't have to repaint the color window underneath when you moved or dismissed it:

https://donhopkins.com/home/archive/psiber/cyber/pointer.ps

ActorNightly3• 28 days ago

Oh please. Steve would have made the Mac Book even worse functionally, but it would have had prettier aesthetics.

Dude was the definition of narcissism.

anotherpaul• 29 days ago

This is such a nice fix but then you install it's set it up to launch on start and forget about it. 5 years later the bug has been fixed for 4 and I still have tho script record a random pixel every 10 seconds. Never know how to know that the hacky fix is no longer needed

nehal3m• 29 days ago

You could just put it in your calendar. 'Check if that hacky bugfix at ~/.dirtyhack.sh is still required with chmod -x ~/.dirtyhack.sh'

joxdosba• 29 days ago

Or do a counter with read n<.hackycounter;echo $[n+1]>.hackycounter

When the counter hits e.g. 200, spam the user with notifications.

TheTon• 29 days ago

I’m not sure what the bug is, but this is a terrible fix. What this is doing is forcing the WindowServer to composite the cursor rather than treat it as a hardware overlay. I suppose the issue must be pretty bad for OP if this helps, but … ugh.

nusl• 29 days ago

Terrible fix but it's a fix that's minimally-invasive and addresses a bug that causes a disproportionate annoyance to the fix. I can imagine your cursor lagging is something that is extremely annoying over time.

nok22kon2• 29 days ago

linux was plagued for a long time by lagging mouse cursor

pbmonster• 29 days ago

Reminds me of a fix I wrote a decade ago. My Laptop would sometimes start emitting a high frequency whine when on battery. I figured out it only happened when the CPU went into performance states lower than P2 for power saving.

So I wrote a bash script that auto-started on battery mode and then calculated a hash every few seconds. Boom, whine solved. Terrible fix, but I never measured how much battery it cost me, so it was... fine.

okeuro49• 28 days ago

That reminds me a lot of this xkcd comic where a user depends on an application overheating when the space-bar is pressed.

https://xkcd.com/1172

qingcharles• 28 days ago

Reminds me of some my USB HDDs that spin down and the only sane fix is to just "touch" a file every couple of minutes to keep them running.

BearOso• 28 days ago

Yeah. It simply shouldn't be falling back to a software cursor in the first place. That's the bug.

xnx• 29 days ago

Sometimes the cure is worse than the disease.

y1n0• 28 days ago

“It was a brilliant cure, but we lost the patient.”

inigyou• 29 days ago

What's with "guard !foo else return" instead of "if foo return", is that just how Swift is written?

NobodyNada2• 29 days ago

guard is an inverted if statement, with the additional requirement that the branch must exit the parent scope. It's useful sometimes for readability, particularly for avoiding the "pyramid of doom" when you have a lot of preconditions that need to be checked:

    if fooOK 
        if barOK {
            if bazOK {
                // do something
            }
        }
    }

can be written as:

    guard fooOK else { return }
    guard barOK else { return }
    guard bazOK else { return }
    // do something

Obviously there are other options (like writing a negated if), but sometimes guard is more readable. It's a style thing.

The more important use case for guard is that 'guard let' statements can pattern-match and introduce bindings that are valid for the rest of the scope:

    guard let foo = someOptional else { return }
    print(foo);

This is useful enough that Rust copied it in the form of 'let ... else {}' statements (but did not bring over boolean guard statements).

silvestrov• 29 days ago

Perl has the negated if statement:

    return unless fooOK;
    return unless barOK;
    return unless bazOK;
    # do something

adrian_b• 29 days ago

Already in 1963, the language CPL introduced "unless ... do ...", besides the "if ... do ..." inherited from ALGOL 60. Perl has just followed the example of CPL and BCPL, decades later.

Using "if" or "unless", whichever is more appropriate, is far more readable than "guard".

Moreover, there are many languages where an assignment or an initialization can appear in any place where an expression can appear. Such general rules are always better than special rules like allowing new bindings in a "guard", but not in an "if". Pattern matching does not need any special syntax, it should work in the standard alternative program structure of that programming language, regardless whether it is called "select", "case" or "switch".

It always annoys me when the creators of new programming languages demonstrate amateurism, by inventing new worse alternatives than those that existed in various older programming language, already many decades ago.

There are plenty of new programming languages that claim to be better than C, which may be true, but they fail to match programming languages much older than C.

wwalexander• 29 days ago

guard has two advantages: the compiler ensures that you exit the current scope if the condition does not hold (via return, break, continue, etc), and bindings established in the guard clause (e.g. let foo = optionalBar) remaining in scope after the guard block, rather than inside it like an if block.

swiftcoder• 29 days ago

Is the fix working because it forces the WindowServer to do a full composition of the cursor overlay, or just because it prevents the system from throttling down into a lower power mode?

adithyassekhar• 29 days ago

The duality of TheTon’s and anotherpaul’s comments.

userbinator2• 29 days ago

But at the moment when it lags the system switches from hardware cursor to software cursor (CGCursorIsDrawnInFramebuffer() goes from 0 to 1) so maybe that transition is stalled somehow on Macbook Neo.

With the disclaimer that I have zero knowledge of the MacBook Neo hardware, but I do know a bit about GPUs in general (including having written some GPU-accelerated drivers for Windows and the associated cursor-handling code), I'm going to make a wild guess: this lag is caused by waiting for the GPU command queue to flush.

As a bit of background information: the GPU is fed commands from a queue that the CPU writes to. These commands perform the drawing operations that the GPU is designed to accelerate. A hardware cursor is basically a small bitmap that can be positioned anywhere on the screen and moved around by simply updating position registers (which is normally done per mouse interrupt); the hardware draws it automatically. A software cursor is manually drawn by the graphics stack, which saves what was under it, draws the cursor, and then whenever it needs to be moved, writes the original data back, saves the data at the new position, and then draws the cursor there.

Flushing the command queue is necessary when switching to a software cursor, or otherwise doing software writes to the framebuffer, because you need to wait for the GPU to finish drawing what it has queued, or it may end up drawing over what software wants to draw, including the cursor. Or worse, the command is a blit (e.g. scrolling a window) and you end up with remnants of the cursor at its previous position.

jstanley• 29 days ago

But wouldn't the software cursor operations also go in the queue? I don't see the problem.

userbinator2• 29 days ago

For something as small as a cursor they could be doing direct framebuffer writes.

ralferoo• 29 days ago

Modern GPUs usually have multiple command queues, at least one for application use (often separate queues for rendering and compute) and one for OS use. There's a good chance that this wasn't implemented on a chip intended for a phone.

bloqs• 29 days ago

This was a really informative and interesting reply articulated in simple enough terms that I am now interested in GPUs, thanks

charcircuit• 29 days ago

A software cursor is manually drawn by the graphics stack, which saves what was under it, draws the cursor, and then whenever it needs to be moved, writes the original data back, saves the data at the new position, and then draws the cursor there.

If a hardware layer is not being used the cursor layer will be treated like any other layer in the compositor. Modern compositors don't try and save and write pixels like that. It will just rerender it.

(which is normally done per mouse interrupt);

It's normally done every frame the compositor makes.

or it may end up drawing over what software wants to draw

The compositor composites everything at that will be shown on the next refresh of the display. Things don't indepently step on each others toes since it's just the compositor rendering and synchronizing all hardware layers (planes).

nok22kon2• 29 days ago

how do hardware cursors work in a composited desktop?

the cursor could just be another small rectangle texture you position on top of the other surfaces. there is no need to read the framebuffer/write into it, its just a z-stack of 3d surfaces now

ahartmetz2• 29 days ago

AFAIK, they work just like in a non-composited desktop.

The problem with rendering the cursor into the primary plane is that, often, only the cursor changes, and you'd have to re-render the whole plane that contains the cursor. That is easily doable for modern hardware, but bad for power consumption and may also be higher latency. (The latency aspect gets interesting when dragging something on the primary plane - I think most compositors temporarily disable the hardware cursor in order to keep cursor and dragged object in sync.)

raphlinus• 29 days ago

This is plausible to me as well. A couple years ago we were trying to make dynamic memory allocation in Vello more robust and explored using async readback of a status buffer. In that case, the async task doesn't wake until the command buffer completes and signals a fence back to the CPU.

Long story short, performance was disappointing and we abandoned the approach. It's easy to believe it's a real problem especially when there are other factors including GPU being clocked down to save power.

Same caveat as parent, I have no direct knowledge of MacBook Neo or this specific issue.

arghwhat5• 29 days ago

The display controller and render device are completely distinct logical devices, even though they are often grouped in a "GPU". On mobile architectures they are quite far separated, leading to annoying problems surrounding what we on Linux call "split drm devices".

Updating plane properties such as to move the cursor plane around or disable it would by itself not block on render activities, as they are completely distinct blocks.

The render hardware could be powered down, but I doubt powering it up and compositing the cursor would take long enough to complete to cause any noticable lag.

Under the Linux APIs, updates to the display controller are done through KMS atomic commits, and one mistake you could do display-server side would be to provide a fence in this atomic commit that the scheduler will use to wait on long-running GPU work before using the provided graphics buffers. Under this API, none of the changes - including mouse movements - would then be applied until that fence is signalled. Changing plane associations can lead to resource reallocations that can be a bit heavy.

Not sure if the kernel driver in macOS works anything remotely similar to this, and the driver could also just be dumb and block on unrelated things ("let's just wait another vblank to see this apply....", "as we only need one plane now let's power down hardware and wait for that to settle..."). It could also just be windowserver that waits for work to finish on its own, not providing any cursor updates in the meantime.

The reality is that it will take reverse engineering or looking at actual code to know what's going on.

eptcyka• 29 days ago

Since this is but an iPhone crammed into a laptop, could this behaviour stem from the fact that iPhones generally need not render a cursor?

Someone• 29 days ago

A hardware cursor is basically a small bitmap that can be positioned anywhere on the screen and moved around by simply updating position registers (which is normally done per mouse interrupt); the hardware draws it automatically

Do modern machines still have custom hardware for cursors? That would surprise me, as a GPU can easily blit a small cursor on top of whatever gets drawn.

ahartmetz2• 29 days ago

The cursor plane is the way to "easily blit a small cursor on top of whatever gets drawn". If the cursor was drawn on the primary plane, the primary plane would need to be redrawn (expensive!) or repaired (messy!) to change the cursor position.

unconed• 28 days ago

A software cursor is manually drawn by the graphics stack, which saves what was under it, draws the cursor, and then whenever it needs to be moved, writes the original data back, saves the data at the new position, and then draws the cursor there.

AFAIK this hasn't been true for a long time on most platforms, certainly on macOS. The desktop image is composited on the GPU by assembling the underlying windows with appropriate effects like shadows and scrolling/scaling. A software cursor is just another overlay which may also have a transparent shadow.

Actually preserving what was under the cursor and putting it back is the sort of thing you wouldn't do anymore, because that's a cache which requires babysitting based on everything that's underneath and around it.

e.g. On macOS there's full screen zooming for accessibility, and if you wiggle the mouse, the cursor grows in size briefly (maybe even too big for hardware cursor to support).

alvaniss• 29 days ago

ah yes, the famous mac "Just works" OS

koiueo2• 29 days ago

What's the big deal?

It's just a simple one-liner

curl github.com/trustworthyguy/fix_everything | sh

And it all works. Not like recompiling entire kernel to play an mp3.

/s obviously

flyingshelf• 29 days ago

That was like 20 years ago. My computer insists on downloading gigabytes of videos at random (correction: specifically when I use the hotspot) because maybe I have a video screensaver enabled.

I had to set up a daemon to kill the downloader every 10 seconds.

nicman23• 29 days ago

host file nuke?

libria• 28 days ago

I think this ^ and the "Steve in his grave" comment should be a red flag for Apple execs.

Being flawless and polished at UX, hardware experience, and CX in general are the core of Apple's identity and revenue. Granted, the "hold it like this" thing was a huge gaff.

I also think the Neo is a culture miss that is diluting their brand. Their logo is synonymous with "expensive" and "quality" but the Neo is affordable and now it has cursor stutter.

eviks2• 28 days ago

Being flawless and polished at UX, hardware experience, and CX in general are the core of Apple's identity and revenue.

But since they never had all of that, it can't be at the core, so the execs can continue to wave the green $ flag

ActorNightly3• 28 days ago

Being flawless and polished at UX, hardware experience, and CX in general are the core of Apple's identity and revenue.

No, and no.

Apple is at the Ferrari stage of computer hardware.

Ferrari doesn't need to make good cars. They don't even need to make good looking cars (i.e the new Luce). They just need to make cars that are hard to get, with a Ferrari badge. Because the badge carries so much weight, the product is desirable.

Apple is the same way. They could release a terrible laptop, and people will still buy it. Don't believe me? Remember that they had an MBP, pre apple silicon, with comparatively shit specs for the money, and a touchbar with a virtual escape key and a terrible arrow key layout. Thing was actually terrible to use. But yet, because Apple, everyone was still praising it.

zuhsetaqi• 29 days ago

Does anyone know if this is fixed in macOS 27?

vardump2• 29 days ago

Embedded Swift in a script. That seems like a useful concept for small scripts on macOS. I will definitely steal this idea.

thewebguyd2• 28 days ago

Swift also has an interpreted mode, you can just

  #!/usr/bin/evn swift
  import Foundation
  print("Hello, world")

and chmod +x hello.swift and execute it.

Instead of doing swift in bash and calling swiftc, you can always shell out to Process() from inside a Swift script instead.

vardump2• 27 days ago

Thanks! I think both approaches have their uses, neither fully replaces the other.

zx8080• 29 days ago

Round rect corners are to blame?

The root cause for the issue is probably (I'm not an Apple developer) due to huge round rectangles on the window shape corners. Rendering the window with the corners would include rendering whatever other windows and widgets under the window. (Which will have a lag and some more operations with transparency, which the developers probably want to avoid - while I'm not sure about this part).

saagarjha• 29 days ago

elicash• 29 days ago

A fix so amusing and ridiculous it gets the bug enough attention that Apple fixes it for real.

spectral_beel• 29 days ago

i hope they can fix it asap

gcr• 29 days ago

This is a great example of how to make a minimal app bundle with Swift. Thank you!

All an App needs on MacOS seems to be a binary and a little .plist

whywhywhywhy• 29 days ago

Crazy this would be the case when the MacOS cursor has been buttery smooth and only ever lags if the entire system is about to go down even on 800Mhz G4 Titanium Powerbook this was the behavior.

amelius• 29 days ago

Bonus points if you manage to record the Facebook tracking pixel.

zetanor• 28 days ago

The Meta EULA does NOT allow you to record their tracking pixel.

ing33k• 28 days ago

is any one here using the neo for any coding work ? how is it ?

taude2• 28 days ago

Not real work. It's an amazing couch laptop, though. I do have a full CLI tooling pipeline setup, though. I mostly read, research, and write on it. Chrome tabs galore open, Obsidian, etc...

It's pretty amazing at the price point. Thought last year the M4 Airs were on sale for $749 -- I'm doubtful we'll see that price again on those....

hirvi74• 28 days ago

I do, and I love mine. I program relatively low-resource software, so power is not an issue.

ActorNightly3• 28 days ago

If all you need is a coding laptop, any $200 dollar laptop with upgradable ssd and ram with linux installed does just fine.

taude2• 28 days ago

I'm on a NEO right now, my Chrome has like 25 tabs open. Doom Emacs running in terminal, Obsidian open, Apple Music, Apple NOtes, etc. I have a lot open...

AND I'm not seeing this issue. What am I missing?

I'm on 26.4.

:shrugs:

EDIT: I guess I wait to update and install the latest version? Maybe the linked page could have stated there's a new regression in newer MacOS versions that introduced this?

exogen3• 28 days ago

Before reading the background info, I was going to recommend a much simpler fix, but they actually already mention it in there: "Also the mouse cursor size can be changed."

This was going to be my suggestion because it also fixed a similar CPU/GPU related issue many years ago: Apple's own TV.app would have minuscule color handling differences whenever subtitles would show during a movie. This was driving me nuts while showing a moody black & white film for a movie night - every time a subtitle would pop up, the entire scene's black levels would shift slightly (and it wasn't any kind of adaptive/localized brightness or anything like that, it was the actual rendering).

Some online sleuthing revealed it was GPU related (pure GPU video decoding vs. the CPU overlaying subtitles on the screen), and that bumping up the cursor size (even the tiniest amount) in mouse settings would fix it. It worked.

It's barely noticeable, but I actually prefer the slightly bigger mouse cursor now anyway, so it's part of my standard macOS setup.

MontagFTB• 28 days ago

Do you have links to what you found? That solution sounds plausible in this case.

exogen3• 28 days ago

Not sure if this is the exact same one, but here's one thread I found: https://discussions.apple.com/thread/6026454?answerId=327318...

The cursor size adjustment is mentioned further down on the page.

retroplasma• 28 days ago

Yes, however, a small change of the cursor size doesn't work for me for the Neo lag (idk about the TV app). I have to set it to a size that is significantly bigger, to trigger the fix. (edit: Added that side note to the gist)

exogen3• 28 days ago

Odd, I wonder if it has to do with modern macOS resolution scaling (how there basically is no "native physical resolution" setting anymore). i.e. maybe up to a certain point it's also simply scaling the hardware-rendered cursor, if that's even possible?

dunham• 28 days ago

Back in the 90's I had a Matrox card that would crash the machine if the hardware cursor changed at the wrong time. I think it was related to VBI, but it's been a while.

Linux resolved this issue, but to work around it on windows, I changed my cursor to an animated dinosaur, which was built into the OS and had the side-effect of disabling the hardware cursor.

Sidnicious• 28 days ago

This issue was related to an old macOS optimization called "detached mode" or FSLP (fullscreen low power). There were related bugs in Chrome and Firefox:

- https://issues.chromium.org/issues/41359717

- https://bugzilla.mozilla.org/show_bug.cgi?id=1747999

macOS skipped compositing when only a single fullscreen surface with a black background was being rendered, but there were many ways for that render path to misbehave.

It only ever affected integrated graphics on dual GPU Macs, as far as I can remember.

dcrazy• 28 days ago

Detached mode still exists on Apple Silicon. If you enabled the Metal HUD in a game it will tell you whether the game is rendering in Detached or Composited mode.

roody15• 27 days ago

I have found this to be true. I manage an organization with around 600 Apple laptops and now when setting them up I always increase the cursor size slightly. No one complains and it does appear to be a smoother experience.

PaulHoule• 28 days ago

One of the most damning indictments of current software architecture is the laggy mouse which we've all gotten used to on mainstream OS.

The other day my son and I were sitting in front of the XBOX ONE we (try to) use as a Plex client and laughing about how showing a new logo while the machine is doing something meaningless to us is an act of brand destruction and that they should be showing us a Playstation logo instead... And how with the NES you could just hit the power button and start playing. The cursor never lagged like that on the 1984 Mac.

thewebguyd2• 28 days ago

Its also one of the most immediately visible degradations of user experience. The cursor is your agent to interact with the computer, an extension of your arm basically. It should be one of the most smooth and responsive pieces of an OS.

I remember a long time ago, early days of Gnome 3 when doing large file operations would hang the cursor. It made the whole system feel like complete garbage, totally unacceptable.

A cursor lagging (or any kind of GUI/user interaction stutters) should be a critical high priority bug, all hands on deck sort of thing. The entire experience of using the damn thing hinges on the responsiveness of the interface and pointing devices.

fragmede• 28 days ago

It's debatable if the cursor working but not being able to interact with any of the screen elements is more or less janky than if the mouse is stuttering but you can interact with the elements on the screen.

gorfian_robot2• 28 days ago

reminds of a prank we pulled on a coworker back in the xterminal days. every time he hit a certain key it would invoke the 'melt' screensaver briefly. he was fairly unobservant though and we had to escalate to invoking it for 1s every minute before he finally noticed.

the follow on prank was having all the xterminals 'moo' whenever new code was deployed to prod.

ramses0• 28 days ago

That’s amazing! I am just imagining a room full of programmers with slightly divergent crontab start times all playing a "moo" sound effect, seemingly at random... not a bad ambient information radiator, actually!

gorfian_robot2• 26 days ago

ambient information radiator. I like that term and have always been interested in it. for a while we had a system monitoring connected to a speaker that produced fairly consistent tonal patterns. when it started sounding 'weird' it usually meant something was off.

mproud• 28 days ago

Is there a Radar open for this?

da_grift_shift• 27 days ago

Exactly my question. 600 lines of Swift-in-shell-wrapper and Claude couldn't have run sysdiagnose and vibed out a quick report to throw into Feedback Assistant?

bryan_w• 28 days ago

This feels like something Steve Jobs would have slapped someone for allowing to be shipped to production

"Fix" MacBook Neo Cursor Lag: Record 1 Pixel of the Screen Every 10 Seconds

Related Stories