I made Window Assassin, a tiny Windows tray utility for those moments when an app freezes and refuses to close.

Focus the window and press Ctrl+Alt+End. It immediately terminates the process behind the active window.

Features:

• global Ctrl+Alt+End hotkey

• elevated execution for stubborn apps

• optional Start with Windows

• installer and portable ZIP

Warning: forced termination skips save prompts, so unsaved work will be lost.

Free / pay what you want: https://b2kdaman.itch.io/window-assassin

This is my local AI Server. It runs the best local model around qwen3.8:27b via ollama. I was inspired by Digital Spaceport on YouTube to make a 8-bit style arcade suite in a html file so i can host it on my website. I used hermes for my agent and it worked great, after a few update prompts it was finished - PIXELARCADE.

Ollama question:
The system has 40GB of Vram. qwen3.8:27b uses 23gb of vram in my setup. When I run gemma4:12b while qwen3.8:27b is loaded, 9.7gb is used. but the CPU is being used with a 16%:CPU 84%:GPU split. Why dose this happen? how can i fix it? will llama.cpp solve my issues?
This server only supports 1-2 users and I would like to run qwen3.8:27b and one more smaller model.

https://sikiru-ekunsumi.xyz/Projects.html

https://digitalspaceport.com/qwen-3-8-27b-review-prompts-and-vllm-settings/

I previously reported a result of 74% on BU bench v1, with the open-source BrowserAgent harness, but I forgot to set the temperature to the default specified in the model card... Now the model performs neck to neck with GPT 5.6 Luna (xhigh) and beats all other affordable models that I tested.

Qwen3.8 27B is insanely good value!

After about a year of building, testing and constantly finding things to improve, Nyx AI is finally out. It is available in 240 markets and 6 languages.

Nyx AI is a local first AI workspace for Windows for chat, coding, documents, previews and automation.
You can run models locally through Ollama or connect OpenAI, Anthropic, Ollama Cloud or your own compatible endpoint. No Nyx AI account is required for local use.
One area I spent a lot of time on was agent safety.

In Nyx AI Lab the model can work with files, run shell commands and Python, use Git, run builds and tests, and preview PDF, DOCX, XLSX and PPTX files.
Locked execution uses Windows AppContainer isolation where supported, alongside workspace file controls, command risk checks, approval controls and native Windows confirmations for certain higher risk actions.

There is also a built in privacy sanitiser designed to detect and redact recognised sensitive information before messages are sent to non local models. It is best effort and cannot guarantee that every sensitive value will be detected.

No sandbox is completely secure and these controls reduce risk rather than eliminate it. The limitations and residual risks are documented in the public threat model, and the legal and technical documents are available inside the app.

Would genuinely appreciate anyone trying it and telling me what you think.

Website
[https://nyxai.uk
Microsoft Store
)Microsoft store nyx ai

pagedMark removes AI provenance from content you generated yourself. Two different things, and it is worth separating them. The first is metadata: C2PA Content Credentials, EXIF, XMP, IPTC, the generator parameters. That part is easy and verifiable, and a screenshot does it too. The second is the invisible pixel watermark that a screenshot does not touch, the SynthID class of marks, which has to be disrupted by regenerating the image itself.

Coverage on the image side is ChatGPT, gpt-image, DALL·E, Sora, Gemini and Nano Banana for the invisible marks, plus a registry of visible vendor labels (Doubao, Jimeng, Qwen, Kling, Yuanbao, Baidu, LibLibAI, Samsung Galaxy AI). On the video side it handles the visible marks from Sora, Veo, Seedance, Dola, Hailuo and Kling, and the metadata that travels with them.

The reason this is worth a post rather than a link is that it is built for Apple Silicon instead of ported to it. I spent several days getting the pipeline to run correctly on an M5 with 16 GB, meaning predictable and measured rather than merely launching. Most of what I assumed turned out to be wrong, so the measurements are below.

The four-step distillation LoRA invents texture, and more steps make it worse

A low strength edit runs the tail of a long schedule: strength 0.15 executes the last four steps of twenty seven. A LoRA distilled for four timesteps spanning the entire noise range is off its distribution there. Wherever nothing conditions the model, and flat dark fabric gives a Canny ControlNet no edges at all, it fills the gap from its prior. On a night photograph that arrives as coloured camouflage across black clothing.

Global stage, 1448x1080, strength 0.15, seed 0	Invented texture	PSNR	Wall
Lightning, 4 steps	1.73x source	28.54 dB	41 s
Lightning, 8 steps	1.80x	28.19 dB	29 s
Lightning, 16 steps	1.84x	27.85 dB	62 s
Undistilled base, 16 steps	1.19x	29.25 dB	71 s
Undistilled base, 24 steps	1.20x	29.17 dB	132 s

Asking the distilled model for more steps made the artifact worse, which is what identified the distillation rather than the step count as the cause. Dropping the LoRA costs roughly three times the wall time and buys back both fidelity and correctness.

Three wrong theories I paid for first, in case they save someone else the time. Not the fp16 VAE: a bare encode and decode round trip of the same crop is clean in fp16 and in fp32, tiled or whole, at 34.6 dB. Not Metal's fp16 in general: bf16 measured marginally worse. Not Canny picking up sensor noise: the Canny map of that region is completely empty, which was the actual clue.

Metal pages instead of failing, so memory has to be measured

torch.mps.recommended_max_memory() reports 11.84 GiB on a 16 GB machine. Exceed it and nothing raises an error. The process starts swapping, and a run that should take 23 seconds takes an hour instead.

With VAE tiling disabled, a 1.57 MP frame peaks at 18.74 GiB and takes 59 seconds. With tiling it peaks at 10.92 GiB and takes 23 seconds. So tiling carries real weight on a small machine, but its boundaries leave a faint texture, which is why it is now decided per frame from the device budget rather than switched on globally.

Diffusion untiled at 2.5 MP went into swap and did not finish within twelve minutes. Tiled at 1024 px, a 5.07 MP frame holds 10.93 GiB, finishes in 88 seconds, and keeps its native geometry.

Sequential CPU offload works on MPS, and it is what makes 8 GB usable

The stack is 7.7 GiB of weights. An 8 GB Mac reports a working set of roughly 5.3 GiB, so it does not fit however the activations are handled. Streaming the weights one module at a time:

Same frame, same seed	Peak device memory	Wall
Weights resident	7.70 GiB	7.1 s
enable_sequential_cpu_offload(device="mps")	0.28 GiB	24.1 s

Twenty seven times less peak memory for 3.4 times the wall time. The plan is chosen from the measured budget and then printed, because a run three times slower than the fast path looks broken unless it says why.

Two Metal gaps worth knowing if you are porting anything

torch.float8_e4m3fn does not exist on MPS at all. The error is RuntimeError: Undefined type Float8_e4m3fn. Any pipeline that streams float8 weights, which several VRAM managed stacks do, cannot be loaded there under any configuration.

SAM's processor emits its box and point prompts as float64, which Metal also has no type for, so moving the batch to the device raises rather than degrading. A single cast fixes it, but nothing tells you that is the problem.

The expensive one: fp16 sampling on MPS returns zeros silently

I added a memory optimisation that encodes the two fixed prompts once and drops the text encoders, saving a measured 1.52 GiB of the 8.79 GiB the loaded stack holds. Two of four face crops then came back as all zero black rectangles. Deterministically, at the same seed, with nothing raised anywhere.

The embeddings were innocent. CPU fp16, MPS fp16 and fp32 encodings of that prompt agree to 0.0009 on tensors with a standard deviation of 3.06, and the same crop generated in isolation is correct either way. Freeing unrelated memory changed the allocation pattern the crops met after the global pass, and that alone was enough. I withdrew the optimisation and added a guard that drops any empty crop instead of compositing it.

If you run fp16 diffusion on Metal, check your output for degeneracy. It will not tell you.

What it does not claim

Regeneration is not payload deletion. The image changes: faces, text and fine detail move, and the numbers above are the measured size of that change rather than a reassurance.

No public local decoder exists for SynthID class marks, so identify reports unknown and never clean. Verification is the provider's verifier or nothing. The 0.15 operating point comes from the upstream project's record against openai.com/verify on CUDA. I have not re-run that check on Metal, and Metal is not bit identical to CUDA, so I am claiming the same operating point and not the same verdict.

It is for content you generated or own. The visible mark registry accepts AI generation labels only. Stock agency previews, marketplace and classifieds watermarks are deliberately out of scope, and that boundary is in the repository rather than only in this comment.

Because "how much did that cost my picture" is the whole question

pagedmark measure before.png after.png

PSNR over the frame, PSNR per detected face, and how much mid band structure appeared where the source was flat and dark. The third metric is the one that caught the camouflage, and it took two attempts. Per pixel chroma statistics rank the artifact below the source, because the source's own sensor grain carries more per pixel variance than the invented blotches do. A plain band ratio fails too, since any linear filter reports doubled grain and doubled blotches identically. Normalising mid band energy by fine detail energy, against the same ratio in the source, measures the shape of the spectrum instead of its size.

uv tool install "pagedmark[diffusion]"
pagedmark invisible photo.png -o clean.png
pagedmark invisible photo.png --preview      # 46.6 s instead of 112.6 s

Code: https://github.com/doofzoff/pagedMark
PyPI: https://pypi.org/project/pagedmark/

Happy to answer anything about the Metal specifics. That is the part I would have wanted written down before I started.

I'm the developer, and this is my project, so read it with that in mind.

The part I think is actually interesting is a refusal, so I'll start there. My app can run AI-generated shell commands and Python inside a Windows sandbox using AppContainer. Before it treats a sandbox level as available, it tests on your machine that Windows is actually enforcing that boundary, and it fails closed when a sandbox level you chose can't be established: the command is refused rather than run with weaker protection. The UI always shows which isolation level actually ran, because "sandboxed" is a claim and the app should have to prove it.

The app is Nyx AI, a Windows desktop workspace built around an AI agent. It does documents, spreadsheets with live formulas, slide decks, PDFs, web research and data analysis as well as code editing and shell work. You bring your own model: Ollama running on your PC with no API key stored in the app, or your own OpenAI, Anthropic or Ollama Cloud account. It ships no models and no inference runtime, so local means installing Ollama yourself first.

Honest qualifier on "local-first", because you'd catch it anyway: a local Ollama model keeps ordinary prompts on your PC, and small background helper calls can use a local model when one is available. On the Auto routing setting, though, heavier coding, reasoning and planning work normally prefers a cloud route you've configured. Local-first is a supported way to run it, not a guarantee that nothing ever leaves the machine. The docs say exactly that.

There are four isolation levels: Automatic, Standard, Sandbox + internet, and Sandbox · no internet. They use two Windows mechanisms: AppContainer for the two Sandbox levels and a Job Object for Standard. Standard is documented as not being a filesystem or network jail.
At the no-internet level, the sandbox is created without internet capability, so the operating system itself refuses outbound traffic from AI-run code. That still isn't an air gap for the whole app: chat still goes to whichever model provider you chose, and the update check, dependency installs you approve, and one-time component downloads can still touch the network. The threat model lists all of it.
Approvals come in two kinds. Ordinary ones are cards inside the app. Higher-risk model actions and certain sensitive operations can require a native Windows confirmation dialog outside the model-controlled interface. Nothing sent from the chat window can mark an action pre-approved, and if the dialog can't be shown the action is refused.

A smaller set of prohibited actions is refused outright in every mode and never offered for approval at all.
There's also an audit trail: a plaintext action log, plus an encrypted, hash-chained forensic log of approvals, denials and sandbox blocks. If a recorded entry is later altered, verification can show it. The docs also state plainly that this cannot prove nothing is missing.
Now the parts you'd find out anyway, so here they are first.
Windows 10/11 x64 only, because the sandbox is built on Windows-specific isolation. There is no macOS, Linux or Windows-on-ARM build.
It is proprietary and closed-source, free for personal non-commercial use, with a separate licence required for commercial use.

Because the source is not public, I have tried to make the externally verifiable parts unusually transparent. The full threat model is public, including trust boundaries, network paths and residual risks, and you can independently monitor its network behaviour.
It's beta software. It has not been independently audited. Prompt injection is documented as not solved, and the app itself ships the line "no sandbox is 100%".
Nyx AI sends no usage analytics, telemetry or crash reports of its own. Automatic update checks are on by default and can be disabled. A check sends the installed version, and the connection necessarily exposes the requesting IP to the update host. Installing from the Microsoft Store also means Microsoft's own platform diagnostics apply under Microsoft's terms, not the app's.
Site and threat model:
https://nyxai.uk

Install is through the Microsoft Store. The website does not host the installer.

Two things I'd genuinely like opinions on.
Where would you draw the line between approvals that deserve a hard OS dialog and ones where an in-app card is enough?
And if you read the threat model, what's missing from it?

New Row-Bot demo: turning your inbox into an action plan.

​

Row-Bot checks important emails, finds action items, drafts replies, creates calendar events, and schedules reminders, with approvals for sensitive actions.

​

Not just chat. Real workflow automation.

​

[https://github.com/siddsachar/row-bot\](https://github.com/siddsachar/row-bot)

When Qwen3.8-27B dropped on Thursday the obvious question came up for us : does a 27B dense model actually fit on the 24GB Mac Mini machines? Ran it properly over the weekend on an M4 Pro (24GB unified, macOS 26.6.1, llama.cpp b10488, bartowski GGUFs). Numbers and gotchas below.

Speed (llama-bench, 3 runs each, flash attention on, full GPU offload):

Quant	File size	pp2048	tg128
Q4_K_M	17.77GB	96.8 tok/s	11.4 tok/s
IQ4_XS	15.57GB	95.4 tok/s	10.9 tok/s

Basically identical speed, so take IQ4_XS: the 2GB you save goes straight into context headroom. Q5_K_M and up, forget it on 24GB.

The three settings that matter:

1. Raise the GPU wired limit. macOS won't wire 17.8GB to the GPU by default on a 24GB machine. sudo sysctl iogpu.wired_limit_mb=20480 fixes it (resets on reboot). After this, Metal reports a 21.5GB working set and the whole model loads clean.
2. Quantise the KV cache for context. With IQ4_XS + -fa 1 -ctk q8_0 -ctv q8_0, a full 32k context loads and answers fine: ~16.6GB resident, 20% of system memory still free.
3. Turn thinking off for interactive use. This is a reasoning model and at 11 tok/s that hurts: our first coding prompt produced 6,500 characters of chain-of-thought and hit a 1,600-token cap without ever starting the answer, 142 seconds of deliberating. With "chat_template_kwargs": {"enable_thinking": false} in the llama-server request, the same prompt returned a complete working Python tool in 28 seconds. Keep thinking on for batch/overnight jobs where the quality gain is worth the wait.

One more thing: llama-cli with a raw -p prompt ran away on us and dumped gigabytes of output. Use llama-server, it handles the chat template properly and you get the web UI for free.

Verdict: genuinely usable at 4-bit, ~11 tok/s is slow but okay for off line tasks and just about bearable reading speed. Q4 output quality is strong. But it's the ceiling for 24GB: no room for Q8 (28.6GB), no room for the vision encoder next to a big context, no room for the rest of your stack. The full writeup with methodology is here: https://halfpennymac.com/qwen38-27b-m4-mac-mini-benchmark

Happy to answer questions or rerun anything with different settings, the test machine is sitting next to me.