No. What in my comment gave you that impression?

Google Maps

This is New York City, and from the Google Street View image, it looks like there’s not a lot of street parking there.

My guess is that a number of cities with a lot of density, like NYC, probably should mandate a certain amount of public parking garage space for users in an area. Multistory parking garage space isn’t cheap, but using up street space via committing space to street parking also has costs in terms of congestion, even if the business owner doesn’t bear the costs.

EDIT: I also note, by way driving the point home with a sledgehammer, that in my Google Street View image, there’s a different vehicle parked on the sidewalk in the same spot, a red sports car.

GitHub explicitly asked Homebrew to stop using shallow clones. Updating them was “an extremely expensive operation” due to the tree layout and traffic of homebrew-core and homebrew-cask.

I’m not going through the PR to understand what’s breaking, since it’s not immediately apparent from a quick skim. But three possible problems based on what people are mentioning there.

The problem is the cost of the shallow clone

Assuming that the workload here is always --depth=1 and they aren’t doing commits at a high rate relative to clones, and that’s an expensive operation for git, I feel like for GitHub, a better solution would be some patch to git that allows it to cache a shallow clone for depth=1 for a given hashref.

The problem is the cost of unshallowing the shallow clone

If the actual problem isn’t the shallow clone, that a regular clone would be fine, but that unshallowing is a problem, then a patch to git that allows more-efficient unshallowing should be a better solution. I mean, I’d think that unshallowing should only need a time-ordered index of commits referenced blobs up to a given point. That shouldn’t be that expensive for git to maintain an index of, if it doesn’t already have it.

The problem is that Homebrew has users repeatedly unshallowing a clone off GitHub and then blowing it away and repeating

If the problem is that people keep repeatedly doing a clone off GitHub — that is, a regular, non-shallow clone would also be problematic — I’d think that a better solution would be to have Homebrew do a local bare clone as a cache, and then just do a pull on that cache and then use it as a reference to create the new clone. If Homebrew uses the fresh clone as read-only and the cache can be relied upon to remain, then they could use --reference alone. If not, then add --dissociate. I’d think that that’d lead to better performance anyway.

I don’t run a home automation system, but if you want an open solution and are willing to do some configuration, my understanding is that the main contenders are OpenHAB and Home Assistant.

I’d also suggest !homeautomation@lemmy.world as a more-specialized resource than !selfhosted@lemmy.world, though I imagine that there’s overlap.

Report claims Nvidia will not be releasing any new RTX gaming GPUs in 2026

https://www.tweaktown.com/news/110017/amds-rdna-4-focus-for-2026-will-reportedly-be-one-gpu-the-radeon-rx-9060-xt-8gb/index.html

AMD’s RDNA 4 focus for 2026 will reportedly be one GPU, the Radeon RX 9060 XT 8GB

Sounds like current hardware is going to stay current for some time.

Tokyo and London are confirmed as the company’s first international markets

Apparently their software is capable of driving on the left.

I don’t know if “GPUs” is the right term, but the only area where we’re seeing large gains in computational capacity now is in parallel compute, so I’d imagine that if Intel intends to be doing high performance computation stuff moving forward, they probably want to be doing parallel compute too.

Amazon’s Fallout countdown delivers possibly the only thing more pointless than a New Vegas or Fallout 3 remaster

I’d buy a remaster.

Mix and match login managers and desktop environments

So, I was wondering if it would be possible to use just the GDM login prompt, but have it feed into KDE desktop and if so what I’d need to tinker with to configure it.

I imagine that it’d depend on the login manager.

I use emptty, which allows me to log in on a text console.

For that login manager, I:

Add a ~/.config/emptty-custom-sessions/sway-wrapped.desktop file:

Name=Wrapped Sway
Exec=/home/tal/bin/my-wrapped-sway.sh
Environment=wayland

And add ~/bin/my-wrapped-sway.sh:

#!/bin/bash

. ~/.bash_profile

export XDG_SESSION_TYPE=wayland

exec dbus-run-session sway "$@"

I mark my-wrapped-sway.sh executable (chmod +x ~/bin/my-wrapped-sway.sh), and done.

searches

https://blog.boristerzic.com/posts/2023-09-17-build-your-own-desktop-environment/

Adding a New Custom Desktop Environment in Arch Linux

Your desktop environment is typically started right after your login to the system using your display manager (or login manager). In graphical display managers like gdm you can select one of several session types from a list. This is where we want to add a new entry for our labwc based desktop environment.

On Arch linux these sessions are stored in /usr/share/xsessions in separate .desktop files. A /usr/share/xsessions/labwc.desktop file could look like this:

[Desktop Entry]  
Encoding=UTF-8
Name=labwc
Comment=labwc
Exec=labwc
Type=Application

I’d probably give that a try.

It sounds like it’s intentional at this point.

https://en.wikipedia.org/wiki/Golden_Gaytime

The company appears to embrace the camp name by retaining the tagline from the 1980s, “It’s hard to have a Gaytime on your own”. Footage from the 1980s commercials were reused in 2015 to celebrate the launch of the new flavours. The in-home boxes feature the words “4 delicious chances to have a gay time”.[15] Ads featuring the slogan also occasionally featured men who would accidentally get into risqué positions whilst trying to get a Gaytime.

Someone almost managed to inject a vulnerability into the source code for sshd.

You’re probably thinking of the Jia Tan attack on xz; because of a distro patch in Debian, code in xz had the ability to affect sshd. The changes weren’t actually to the sshd source, but trying to use an obscure route to affect sshd.

Notably, this and dotfiles are popular among devs using Mac, since MacOS has nearly all settings available either via config files or the defaults system from the command line. In comparison, Windows is total ass about configuring via the command line, and even Cinnamon gives me some headache by either not reloading or straight up overwriting my settings.

The application-level format isn’t really designed for end user consumption, but WINE uses a text representation of the Windows registry. I imagine that one could probably put that in a git registry and that there’s some way to apply that to a Windows registry. Or maybe a collectiom of .reg files, which are also text.

I’d say that now is one of the strongest arguments for upgradability. Memory is really expensive right now. At some point in something like 1-3 years, it will probably be considerably cheaper. If anything, CPUs and motherboards are expected to be cheaper during this period due to reduced demand for new PCs. If you can tolerate less memory now and want to save money, upgrading then would be a good idea.

Oh, yeah, it’s not that ollama itself is opening holes (other than adding something listening on a local port), or telling people to do that. I’m saying that the ollama team is explicitly promoting bad practices. I’m just saying that I’d guess that there are a number of people who are doing things like fully-exposing or port-forwarding to ollama or whatever because they want to be using the parallel compute hardware on their computer remotely. The easiest way to do that is to just expose ollama without setting up some kind of authentication mechanism, so…it’s gonna happen.

I remember someone on here who had their phone and desktop set up so that they couldn’t reach each other by default. They were fine with that, but they really wanted their phone to be able to access the LLM on their computer, and I was helping walk them through it. It was hard and confusing for them — they didn’t really have a background in the stuff, but badly wanted the functionality. In their case, they just wanted local access, while the phone was on their home WiFi network. But…I can say pretty confidently that there are people who want access all the time, to access the thing remotely.

Might be helpful to have a reproducible test case for it.

The incident began from June 2025. Multiple independaent security researchers have assessed that the threat acotor is likely a Chinese state-sponsored group, which would explain the highly selective targeting obseved during the campaign.

I do kind of wonder about the emacs package management infrastructure system. Like, if attacking things that text editors use online is an actively-used vector.

If the chips are just being hoarded to shut out competitors, which is what the OpenAI deal was rumoured to be about, we could see the unused chips getting bought and used, but equally likely we could see the chips (and dimms and cpus) deliberately shredded to prevent them falling into competitor hands.

By the time the things are cycled out, they may not be terribly compute-competitive, in which case…shrugs

Also, a major unknown is where models go. Say that a bunch of people decide that they can’t get access to parallel compute hardware or a lot of memory, and they research looking at models split up into MoEs or otherwise broken up. Recent LLM models have been oriented towards MoEs. Llama.cpp, and I assume the other engines capable of running LLMs, has the ability to offload experts that don’t fit in GPU memory to main memory when they aren’t actively being used. Then maybe…having a bank of consumer-level 24GB GPUs or something like that is fine, and having chips with direct access to very large amounts of memory isn’t all that interesting. Then, what becomes essential to being competitive changes.

EDIT: I also think that it’s safe to say that more memory will probably always benefit. But I’ll also say that it is also probably very likely that our existing models are staggeringly inefficient with memory. We are still doing early passes at this.

Let me give you an example. I have a LLama 3-based model currently loaded on my Framework Desktop that’s using 96GB of memory for the model and associated storage.

Prompt: What is 1+1?

Response: I can answer that. 1+1 = 2.

Prompt: How about 37 times 12?

Response: 37 times 12 is 444.

Now, those are correct answers. But…in order to make an LLM capable of providing that correct response, to do it purely via running a neural net trained on natural language, we had to stick a really inefficient amount of data into memory. That same hardware that I’m running it on has the ability to do billions of integer computations per second. As of today, the software running that model doesn’t provide it access to the hardware, and the model was never trained to use it. But…it could be. And if it were, suddenly a lot of need for storing edges in some neural net wasted on arithmetic go away.

Plus, we could get better results:

Prompt: What about 783901/76523?

Response: 783901 divided by 76523 is approximately 10.23.

That’s not far off — it is approximately 10.23 — but it should have been rounded to 10.24.

$ maxima -q

(%i1) float(783901/76523);

(%o1)                         10.243992002404506
(%i2) 

So we could probably get more-useful models that don’t waste a ton of space in the model if we gave the model access to the computational hardware that’s presently sitting idle and trained it to use it. That’s an off-the-cuff example, but I think that it highlights how we’re solving problems inefficiently in terms of memory.

Same sort of thing with a lot of other problems that we have (immensely-more-efficient and probably accurate) software packages that we can already solve problems with. If you can train the model to use those and run the software in an isolated sandbox rather than trying to do it itself, then we don’t need to blow space in the LLM on the capabilities there, shrink it.

If we reduce the memory requirements enough to solve a lot of problems that people want with a much-smaller amount of memory, or with a much-less-densely-connected set of neural networks, the hardware that people care about may radically change. In early 2026, the most-in-demand hardware is hugely-power-hungry parallel processors with immense amounts of memory directly connected to it. But maybe, in 2028, we figure out how to get models to use existing software packages designed for mostly-serial computation, and suddenly, what everyone is falling over themselves to get ahold of is more-traditional computer hardware. Maybe the neural net isn’t even where most of the computation is happening for most workloads.

Maybe the future is training a model to use a library of software and to write tiny, throwaway programs that run on completely different hardware optimized for this “model scratch computation” purposes, and mostly it consulting those.

Lot of unknowns there.

I posted in a thread a bit back about this, but I can’t find it right now, annoyingly.

You can use the memory on GPUs as swap, though on Linux, that’s currently through FUSE — going through userspace — and probably not terribly efficient.

https://wiki.archlinux.org/title/Swap_on_video_RAM

Linux apparently can use it via HMM: the memory will show up as system memory.

https://www.kernel.org/doc/html/latest/mm/hmm.html

Provide infrastructure and helpers to integrate non-conventional memory (device memory like GPU on board memory) into regular kernel path

It will have higher latency due to the PCI bus. It sounds like it basically uses main memory as a cache, and all attempts to directly access a page on the device trigger an MMU page fault:

Note that any CPU access to a device page triggers a page fault and a migration back to main memory. For example, when a page backing a given CPU address A is migrated from a main memory page to a device page, then any CPU access to address A triggers a page fault and initiates a migration back to main memory.

I don’t know how efficiently Linux deals with this for various workloads; if it can accurately predict the next access, it might be able to pre-request pages and do this pretty quickly. That is, it’s not that the throughput is so bad, but the latency is, so you’d want to mitigate that where possible. There are going to be some workloads for which that’s impossible: an example case would be just allocating a ton of memory, and then accessing random pages. The kernel can’t mitigate the PCI latency in that case.

There’s someone who wrote a driver to do this for old Nvidia cards, something that starts with a “P”, that I also can’t find at the moment, which I thought was the only place where it worked, but it sounds like it can also be done on newer Nvidia and AMD hardware. Haven’t dug into it, but I’m sure that it’d be possible.

A second problem with using a card as swap is going to be that a Blackwell card uses extreme amounts of power, enough to overload a typical consumer desktop PSU. That presumably only has to be used if you’re using the compute hardware, which you wouldn’t if you’re just moving memory around. I mean, existing GPUs normally use much less power than they do when crunching numbers. But if you’re running a GPU on a PSU that cannot actually provide enough power for it running at full blast, you have to be sure that you never actually power up that hardware.

EDIT: For an H200 (141 GB memory):

https://www.techpowerup.com/gpu-specs/h200-nvl.c4254

TDP: 600 W

EDIT2: Just to drive home the power issue:

https://www.financialcontent.com/article/tokenring-2025-12-30-the-great-chill-how-nvidias-1000w-blackwell-and-rubin-chips-ended-the-era-of-air-cooled-data-centers

NVIDIA’s Blackwell B200 GPUs, which became the industry standard earlier this year, operate at a TDP of 1,200W, while the GB200 Superchip modules—combining two Blackwell GPUs with a Grace CPU—demand a staggering 2,700W per unit. However, it is the Rubin architecture, slated for broader rollout in 2026 but already being integrated into early-access “AI Factories,” that has truly broken the thermal ceiling. Rubin chips are reaching 1,800W to 2,300W, with the “Ultra” variants projected to hit 3,600W.

A standard 120V, 15A US household circuit can only handle 1,800W, even if you keep it fully loaded. Even if you get a PSU capable of doing that and dedicate the entire household circuit to that, beyond that, you’re talking something like multiple PSUs on independent circuits or 240V service or something like that.

I have a space heater in my bedroom that can do either 400W or 800W.

So one question, if one wants to use the card for more memory, is going to be what the ceiling on power usage that you can ensure that those cards will use while most of their on-board hardware is idle.

I mean, the article is talking about providing public inbound access, rather than having the software go outbound.

I suspect that in some cases, people just aren’t aware that they are providing access to the world, and it’s unintentional. Or maybe they just don’t know how to set up a VPN or SSH tunnel or some kind of authenticated reverse proxy or something like that, and want to provide public access for remote use from, say, a phone or laptop or something, which is a legit use case.

ollama targets being easy to set up. I do kinda think that there’s an argument that maybe it should try to facilitate configuration for that setup, even though it expands the scope of what they’re doing, since I figure that there are probably a lot of people without a lot of, say, networking familiarity who just want to play with local LLMs setting these up.

EDIT: I do kind of think that there’s a good argument that the consumer router situation plus personal firewall situation is kind of not good today. Like, “I want to have a computer at my house that I want to access remotely via some secure, authenticated mechanism without dicking it up via misconfiguration” is something that people understandably want to do and should be more straightforward.

I mean, we did it with Bluetooth, did a consumer-friendly way to establish secure communication over insecure airwaves. We don’t really have that for accessing hardware remotely via the Internet.

deleted by creator