u/ImCorvec_I_Interject

I paid for shipping by DHL and it was delivered (earlier this week) by DHL.

Phones aren't hard drives. LE (law enforcement) can't just image a phone if neither the software nor firmware provide them the means to do so.

LE can make a direct copy of the microsd card and analyze that copy - but this is because the firmware on a microsd card makes it available to do so. Likewise with most SSDs. But there are a few specialty (meaning - not generally marketed to consumers) microsd cards with hardware encryption, and there are numerous SSDs with hardware encryption, some of which can outright prevent a clone without the key being supplied. In such an instance, LE would have to bypass the controller by desoldering the NAND and reading it directly - see https://www.youtube.com/watch?v=nhA2AwHf7sU for an overview of this process. The extracted data would still be encrypted, but LE can attack it at rest, wait for an exploit, etc. - and you can't wipe the drive to mitigate that risk.

Unlike cloning drives, modern phones need to be unlocked for most capabilities of the forensic devices that LE use to function. Even then, those tools have limitations. These tools can't create a direct copy of the phone; they have to ask the phone, via USB, to provide them the information necessary to create that copy. Check out https://www.youtube.com/watch?v=od0EjETlqjE for an example of one of the tools that they use, Cellebrite. Now, generally your phone doesn't have to be left unlocked and open like it is in the video - being in the AFU (after first unlock) state is generally sufficient for these forensic tools - but in the BFU (before first unlock) state, these forensic tools can't do much (at least, not without an exploit that allows them to bypass the intended behavior of the Secure Enclave).

The Secure Enclave has the key necessary to decrypt the phone's data (in combination with your PIN), but extracting that key would be both destructive (it would require extracting the chip from your phone at minimum) and extremely difficult (reading the intentionally obfuscated, fused-in key directly off the hardware at a 3-5 nanometer chip density with an electron microscope); it simply isn't done. (It would also still require running the same computationally expensive key generation algorithm to find your PIN/password.) Instead, these tools rely on exploits to try to trick the Secure Enclave into getting more attempts to guess your PIN/password. A 6 digit PIN would require them to spend half a day brute-forcing your device, on average, since even with exploits, every attempt takes a minimum of 80 milliseconds. Two diceware words would take a full month. With 3 diceware words, it's not feasible to get in without your cooperation. That's why they ask for your password.

So if they ask for your password and you give them the password to "Profile B," it's completely technically feasible for a phone to only decrypt the data belonging to Profile B, and to then respond as though Profile A simply doesn't exist. It's not without its own challenges, of course - especially ensuring it isn't noticed with LE having extended access to your device, but if they're only given half an hour to clone it, it's much more feasible. Now, does such a phone exist? Not to my knowledge - but the technology does, e.g., hidden volumes in VeraCrypt, so it's not far fetched.

Can you use the :latest tag of the app-ci image? app is manually built, but app-ci is built and pushed by GitHub Actions.

Per Docker Registry - simplelogin/app-ci tags, :latest currently corresponds to v4.81.4, which was released 18 days ago.

The last release of https://github.com/simple-login/app was 3 weeks ago and there have been 30 releases in 2026. It's bold to say that SimpleLogin is abandonware.

We talking per bear or across all bears? Like say there's 10,000 black bears and 9,000 deaths, that's less than one kill per year per bear. And if most of those are one bear...

Isn't this only true if you're given a copy of the inspection report (which you aren't, unless the person who ordered the inspection gives it to you)?

Doesn't it use xml whereas those default to json? You may just need to make a config change

"Let's fucking go"

The plural of "cloth" is "cloths," not "clothes."

If you want a singular, generic word for clothing, "garment" is the correct word to use.

Not an assumption. Or at least, if it is, it's an accurate one.

From http://www.scholarpedia.org/article/Thermal_touch

When the hand grasps an object, changes in skin temperature can assist in identifying the object and discriminating between different types of objects. These cues become especially important when objects must be identified without visual feedback, such as when reaching for objects in the dark.

Hmm, seems like it's useful for just this sort of thing.

The thermal sensory system is extremely sensitive to very small changes in temperature and on the hairless skin at the base of the thumb, people can perceive a difference of 0.02-0.07 °C in the amplitudes of two cooling pulses or 0.03-0.09 °C of two warming pulses delivered to the hand. The threshold for detecting a change in skin temperature is larger than the threshold for discriminating between two cooling or warming pulses delivered to the skin. When the skin at the base of the thumb is at 33 °C, the threshold for detecting an increase in temperature is 0.20 °C and is 0.11 °C for detecting a decrease in temperature.

So the least sensitive person will be able to distinguish a 0.07 °C difference between the two pills, which is a small enough difference that I would be very surprised if the pills didn't heat up to be distinguishable.

OP is saying that the airline chose to sacrifice your life rather than pay for a random person’s laptop.

paraphilic behaviors, which are classified as disorders.

From https://www.verywellmind.com/what-are-paraphilic-disorders-6822839 but please feel free to find your own source:

"Not all paraphilic interests make up a paraphilic disorder. It’s important to distinguish between paraphilia and a paraphilic disorder. While the former includes unusual sexual urges and behaviors, the latter features paraphilic symptoms that cause distress or impairment to the individual or the risk of harm to yourself or others."

Your study only concerns sexual offenders, doesn't consider paraphilic interest in sexual offenders who don't have a Compulsive Sexual Behavior Disorder, and had a sample size of less than 100. Since you can have a paraphilic interest without a CSBD and since you can have kinks without even getting to the level of paraphilic interest, your assertion that this is direct statistical evidence of your above statement that "there's 100% a link between vore enjoyers and people who are actual sexual predator" is 100% false.

$624 invested yearly with 0% growth would be $6,240 after ten years. How’d you calculate it would take 30 years to make $1490 less at 7% growth?

0.5 FPS is 2 seconds per frame, meaning 1 second of a 24 fps video would take 48 seconds and a 5 second video would take 4 minutes.

NTFY didn't have auth

Ntfy has configurable auth backed by ACLs and supports both username / password login as well as access tokens.

This gives you the flexibility to independently restrict publishing to and subscribing from specific topics or to/from all topics.

ntfy lets you use your own server to deliver notifications.

Heard from a friend in Spain (edit: Well, England since she worked in Gibraltar but still while they were a part of EU) that she didn't get paid if she hadn't remebered to clock in even if everyone agreed she'd worked her shift.

That should go both ways. If she forgets to clock out after a shift, she should keep getting paid for those hours. If a supervisor can't fix it when she forgot to clock in, a supervisor shouldn't be permitted to fix it when she forgets to clock out.

"Why did TDF's friend work 128 hours of overtime last week? Didn't she quit months ago?"

"Yes, but remember how she always forgot to clock in and you told her that her supervisor couldn't fix it? She forgot to clock out on her last day and nobody's been able to get her back here to fix that, either."

"Can't we just clock her out?"

"No, sir, that would be wage theft - our policies are legally required to be consistent and since we didn't pay her when we knew she was working because she didn't clock in, we have to pay her now, even though we know she's not working, because she's still clocked in."

Nice!

To be clear, I'm not saying that you should retire your own server, just that adding the option to connect other TTS servers (not just that specific one, though I mentioned it specifically because of the voice combo feature) would be great. And honestly, after hearing about the work you've put into performance , I wonder how much work it would take to make your server expose an OpenAI compatible API. I just checked and Kokoro-FastAPI doesn't enable MKLDNN. Seems like it should be a pretty straightforward improvement - though it's lacking a few other simple performance improvements, too. I'm pretty sure it only has performance optimizations in place for CUDA.

Some other questions:

• Do you already support / intend to support voice combinations?
• If CUDA is enabled, how much VRAM is used when idle?
• Do you have any plans to add support for AMD and Intel GPUs? I know there's already Kokoro-FastAPI-ROCm on the AMD side; no clue if there's an equivalent for Intel.

Did you mean to reply to me with that video? Kokoro-FastAPI doesn't use WebGPU - it runs in Python and uses your CPU or GPU directly, just like your server.

This looks cool! I've pinned it to check out in detail later.

Any chance of adding support for the user to choose between the server.py from your repo or https://github.com/remsky/Kokoro-FastAPI (which could be running either locally or on a server of the user's choice)?

The following features would also add a lot of flexibility:

• Adding API key support (which you could do by allowing the user to specify headers to add with every request)
• Hitting the /v1/audio/voices endpoint to retrieve the list of voices
• Voice combination support
• Streaming the responses, rather than waiting for the full file to be generated (the Kokoro FastAPI server supports streaming the response from the v1/audio/speech endpoint)

Kokoro-FastAPI creates an OpenAI compatible API for the user. It doesn't require an API key by default, but someone who's self hosting it (like me) might have it gated behind an auth or API key layer. Or someone might want to use a different OpenAI compatible API, either for one of the other existing TTS solutions (e.g., F5, Dia, Bark) or in the future, for a new one that doesn't even exist yet. (That's why I suggested to add support for hitting the voices endpoint.)

I don't think it would be too difficult to add support. Here's an example request that combines the Bella and Sky voices in a 2:1 ratio (67% Bella, 33% Sky) and includes API key / auth support:

  // Defaults:
  // settings.apiBase = 'http://localhost:8880' for Kokoro or 'http://localhost:8000' for server.py
  // settings.speechEndpoint = '/v1/audio/speech' or '/generate' for server.py
  // settings.extraHeaders = {} (Example for a user with an API key: { 'X-API-KEY': '123456789ABCDEF' })

  const response = await fetch(settings.apiBase + settings.speechEndpoint, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      ...settings.ExtraHeaders
    },
    body: JSON.stringify({
      input: text.trim(),
      voice: 'af_bella(2)+af_sky(1)',
      speed: settings.speed,
      response_format: 'mp3',
    })
  );

I got that by modifying an example from the Kokoro repo based off what you're doing here.

Not in Firefox, though.

Counterpoint:

This is in the Ollama repo: https://github.com/ollama/ollama/blob/main/llama/llama.cpp/LICENSE

This is in the Llama.cpp repo: https://github.com/ggml-org/llama.cpp/blob/master/LICENSE

Note that the files are identical.

The issue itself is correct in that this is not technically sufficient (though it is now 'The ggml authors' rather than 'Georgi Gerganov') as the builds of Ollama do not include the copyright or permission notice. However, it's outright false to say that Ollama hasn't credited Llama.cpp at all.

The comment you linked, asking the authors of Ollama to print the entire AUTHORS file from llama.cpp, is not a legal requirement of the MIT license. All that they need to do is start including the LICENSE file (or even a separate line for the authors in a shared LICENSE file) in the builds that they distribute.

The first thing I want to see happen is for a flag to be added that prints the license and the full text of the llama.cpp AUTHORS file which lists the copyright holders. I want the change to be authored by one of you two personally, so everyone can see that Ollama's respect for the community comes from the very top. This should take no more than an hour of your time, but it will accomplish the majority of what's needed to mend things. Afterwards, we should all perform a more detailed analysis of Ollama's dependencies to determine what other works require attribution and how best it should be presented.

Also note that jart wants the change to be authored by one of the founders specifically so that "everyone can see that Ollama's respect for the community comes from the very top." That'd be a pretty nice thing to do if the founders did it themselves, but demanding it is like demanding an apology. It's not sincere if it's forced. And in this case, it comes across – to me, at least – as pretty rude and entitled.

That's related to the other thing that annoys me about that issue. Nobody who wants it has submitted a PR for it. They're not obligated to do that, of course, but it's hard for me to take someone's complaint seriously when they've said it's important and it's a simple change; they've demonstrated that they're competent enough they could do it themselves; and yet they – and nobody else who's agreed with them and complained about it on Reddit – has submitted a PR.

I would be of a very different opinion if someone had submitted a PR and it had gone stale or been rejected. To be clear, I'm still of the opinion that jart is in the right (at least with regard to the originally submitted issue); I'm just not going to boycott Ollama as a result.

some weird hash string in the file name

It's just the result of running sha256sum on the file and prefixing it with sha256-.

I found two open issues on the Ollama repository related to OLLAMA_MODELS not being respected:

• One for Macs that was actually because the user was setting the env through their .zshrc but not running ollama through zsh.
• and one for Windows

Every issue I found for Linux was closed because the cause was similar to the first issue: the env var was not correctly set in the same context that ollama was running.

• https://github.com/ollama/ollama/issues/2940
• https://github.com/ollama/ollama/issues/10803
• https://github.com/ollama/ollama/issues/9263
• https://github.com/ollama/ollama/issues/8641
• https://github.com/ollama/ollama/issues/6553
• https://github.com/ollama/ollama/issues/2676
• https://github.com/ollama/ollama/issues/2571
• https://github.com/ollama/ollama/issues/1737

Please share the Github issues by users on Ubuntu (or some other Debian-based distro) who could not get the OLLAMA_MODELS env var to be respected by Ollama due to an Ollama bug and not due to user error.

Because the wrappers add additional features that make them easier to use via other tools.

If you know how to run llama.cpp in Docker such that it will, without the user of any wrapper or orchestration scripts:

• receive inference requests via HTTP API calls (such that it's accessible via Open-WebUI and other similar tools)
• support handling multiple requests at a time (queuing them and holding them when necessary)
• support having multiple models loaded at once
• automatically load models when requests come in that use them (or at least support loading them via an API call)
• automatically unload them after a configurable idle time, upon request, or if needed when an incoming request relies on a model that isn't loaded and needs to fit into RAM

then please, share that knowledge with the community.