car

https://stanforddaily.com/2016/07/25/knightscope-issues-repo...

https://incidentdatabase.ai/cite/51/

Hey, Gabe Newell might be your man here. But it's not for profit.

https://luxurylaunches.com/transport/gabe-newell-explorer-ve...

https://www.forbes.com/sites/deajusufi/2026/06/13/gabe-newel...

Similar recent posting with optimizations for older Xeon:

High-Performance AI on a Budget: Optimizing llama.cpp for Qwen3.5 Inference on a Dual-GPU HP Z440

https://news.ycombinator.com/item?id=47320244

Probably easier with Trellis 2 or Meshy.ai

I don't know if this gets much personal use, seems real cumbersome.

But this is of huge interest to carriers, since it allows them to skip the PSTN/peering cost when the callee endpoint is an IP phone.

There is private ENUM for carrier use I recall, not sure what the current status is, with LTE/VoLTE, RCS etc.pp.

http://dam3d3.free.fr/PFE/Pathfinder/GSMA_PathFinder_WebSite...

Here the list of countries that have ENUM delegated for their country code.

https://www.itu.int/en/ITU-T/inr/enum/Pages/delegations.aspx

In Germany it is possible to register an ENUM domain for a phone number. This provides a DNS mapping from the E164 number to DNS records, e.g. for IP phones, etc.

Decentralized and under user control, no shitty silos like FaceTime, WhatsApp.

ENUM stands for “Telephone Number Mapping.” It is essentially a bridge between the world of telecommunications and the Internet. With a single ENUM domain, you can combine all your contact options under your familiar phone number:

https://www.denic.de/en/products/enum-domains/

The hierarchical geographical domains you are remembering must have been the 2000 '.geo' Top Level Domain (TLD) proposal from SRI. It didn't work out, but I remember thinking at the time that it was a cool idea.

It would have provided geographical information based on a domain encoded grid, not for human but machine consumption (e.g. acme.2e5n.10e30n.geo).

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

In a similar vein there is the 'e164.arpa' domain for mapping telephone numbers.

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

One of the gems that a publicly funded broadcasting system gave us.

TPU architecture explained

https://news.ycombinator.com/item?id=47637597

A 11 year old dupe, I know. But first time I’ve seen it, and it just added to my admiration for him. And, it’s just as applicable today as it was 24 years ago!

https://news.ycombinator.com/item?id=7567159

Yes, they are listed on huggingface. The instruction trained models have an 'it' in their name.

https://huggingface.co/collections/unsloth/gemma-4

Edit: Sorry, I'm not sure if this is a quant, but it says 'finetuned' from the Google Gemma 4 parent snapshot. It's the same size as the UD 8-bit quant though.

They explain it here:

https://unsloth.ai/docs/basics/unsloth-dynamic-2.0-ggufs

For the best quality reply, I used the Gemma-4 31B UD-Q8_K_XL quant with Unsloth Studio to summarize the URL with web search. It produced 4.9 tok/s (including web search) on an MacBook Pro M1 Max with 64GB.

Here an excerpt of it's own words:

Unsloth Dynamic 2.0 Quantization

Dynamic 2.0 is not just a "bit-reduction" but an intelligent, per-layer optimization strategy.

- Selective Layer Quantization: Instead of making every layer 4-bit, Dynamic 2.0 analyzes every single layer and selectively adjusts the quantization type. Some critical layers may be kept at higher precision, while less critical layers are compressed more.

- Model-Specific Tailoring: The quantization scheme is custom-built for each model. For example, the layers selected for quantization in Gemma 3 are completely different from those in Llama 4.

- High-Quality Calibration: They use a hand-curated calibration dataset of >1.5M tokens specifically designed to enhance conversational chat performance, rather than just optimizing for Wikipedia-style text.

- Architecture Agnostic: While previous versions were mostly effective for MoE (Mixture of Experts) models, Dynamic 2.0 works for all architectures (both MoE and non-MoE).

I don't remember where I got them, but I think they could be copied with an EEprom programmer.

Going down this rabbit hole, I realize that ST hardware for musicians is still huge. And the dongles as still working as intended, apparently.

And then this blew my mind:

https://re-falcon.com

Quite the underground scene:

https://indyclassic.org

Is the software still attractive to use, after all those years, or why are you going to these extremes? Sounds it's somehow intimately intertwined with the dongle, if the check routines can't simply be patched.

Didn't know, thanks for pointing that out. Never used GEM outside Atari, just something I read at the time.

Wow, I just remembered using AES when I wrote an 'accessory' (menu bar app) that converted bitmap to vector for an ST DTP app that supported both. An early form of plugin I suppose. Pretty ahead of the MS mess at the time.

Dongles were a thing, certainly the expensive MIDI programs used them. Cubase, Steinberg and C-LAB Creator were the big ones.

As I recall, there were tons of books about GEM for the Atari ST, at least in Europe.

Apple sued DRI, which resulted in the crippling of GEM, the glaring one I remember were static windows. You heard that right, windows were not resizable but had fixed screen locations in the PC version.

Thankfully Atari licensed GEM for their 68000 machines before the lawsuit, and wasn't affected by these changes. The Atari ST (Sixteen/Thirtytwo) was very Mac like at the time. It even ran the Mac OS from Apple ROMs (Spectre 128 and Aladin) on its much cheaper hardware.

When the Mac and Atari ST first hit the market in the 80's, there were Comics created in this 1-bit "ordered-dither" style. For error-diffusion dithering (Floyd-Steinberg etc.), you needed more bits per pixel, to carry the error.

SHATTER:

https://imgur.com/gallery/shatter-1984-was-first-commerciall...

Robot Empire:

https://www.reddit.com/r/atarist/comments/xgs4rh/comicbook_c...

Thank you for the follow up! Big fan of your models here, thanks for everything you are doing!

Works fine on MacOS now (chat only).

On Ubuntu 24.04 with two GPU's (3090+3070), it appears that Llama.cpp sometimes uses the CPU and not GPU. This is judging from the tk/s and CPU load for identical models run with US-studio vs. just Llama.cpp (bleeding edge).

Andrej Karpathy got one from Jensen Huang.

https://blogs.nvidia.com/blog/gtc-2026-news/#dgx-station

Tried to build from source on MacOS, but got this error:

  (base)   unsloth git:(main) unsloth studio setup
  ╔══════════════════════════════════════╗
  ║     Unsloth Studio Setup Script      ║
  ╚══════════════════════════════════════╝ 
   Node v25.8.1 and npm 11.11.0 already meet requirements. Skipping nvm install.
   Node v25.8.1 | npm 11.11.0
   npm run build failed (exit code 2):

  > unsloth-theme@0.0.0 build
  > tsc -b && vite build

  src/features/chat/shared-composer.tsx(366,17): error TS6133: 'status' is declared but its value is never read.

Can Unsloth Studio use already downloaded models?

For posterity, I can very much recommend MacMousefix. It's $2.99 to own, totally worth it to me. Open source.

https://macmousefix.com/en/

Also available via brew:

  brew install mac-mouse-fix

https://github.com/noah-nuebling/mac-mouse-fix

Can it do FizzBuzz in Brainfuck? Thus far all local models have tripped over their feet or looped out.

Great job, really well done.

Also cool: https://sunclock.net

I enjoy running clocks on this 5" inch circular touch screen IPS display from Waveshare: https://www.amazon.com/dp/B0C14CZ2GG.

The content is provided by a Raspberry Pi 4, and these Javascript/CSS/SVG clocks can be quite taxing. Especially a smooth running seconds hand often causes visual stuttering. Chrome had the best FPS I recall.

If anyone knows of other large circular displays, please post here.

The new BMW Mini has a gorgeous 24cm circular OLED display, but that's not generally available, OEM only [1][2].

[1] https://www.mini.com/en_MS/home/new-family/a-digital-quantum...

[2] https://www.bhtc.com/en/news/bhtc-entwickelt-erstes-rundes-o...

Building Llama.cpp from source with CUDA enabled should get you pretty far. llama-server has a really good web UI, the latest version supports model switching.

As for models, plenty of GGUF quantized (down to 2-bit) available on HF and modelscope.

So great to see my two favorite Open Source AI projects/companies joining forces.

Since I don't see it mentioned here, LlamaBarn is an awesome little—but mighty—MacOS menubar program, making access to llama.cpp's great web UI and downloading of tastefully curated models easy as pie. It automatically determines the available model- and context-sizes based on available RAM.

https://github.com/ggml-org/LlamaBarn

Downloaded models live in:

  ~/.llamabarn

  # bind to all interfaces (0.0.0.0)
  defaults write app.llamabarn.LlamaBarn exposeToNetwork -bool YES

  # or bind to a specific IP (e.g., for Tailscale)
  defaults write app.llamabarn.LlamaBarn exposeToNetwork -string "100.x.x.x"

  # disable (default)
  defaults delete app.llamabarn.LlamaBarn exposeToNetwork

I learned programming on a Sharp MZ-80K. Rectangular sheet metal case with an amber monochrome monitor and a built in cassette tape drive for storage. The keyboard keys were neatly squared up, zero ergonomics. You could flip it open like the hood of a car. And I faintly recall that there was some kind of UV erasable EEprom inside, not sure what for.