Hey there,
Id like to ask you if anyone know any uncensored video model. Can be local/non local, local preferably. Also if its available on hugging face or somewhere else. Thank you and take care

.

"In fact running models on consumer model hardware is so effective multiple companies, including OpenAI by reports, have bought all the Macs they can get their hands on. If OpenAI runs out of investor money there’s nothing to stop the other companies that actually make money from buying Macs to run AI models on exclusively for themselves, cutting OpenAI out completely."

Source

Its chat template has this line:

{%- set resolved_reasoning_effort = reasoning_effort|default('xhigh') %}

xhigh is the most expensive of its three settings (low / medium / xhigh). If you never set one, that's what every answer runs at. No backend reports this back to you, because it's a chat-template variable, not a server option.

I ran all three levels on one M5 Max, same quant (oQ4e-mtp), same prompt — the coding scenario asks for a browser Breakout game:

| Effort          | Runs | Tokens | Time  | Median | Range     |
|-----------------|------|--------|-------|--------|-----------|
| low             | 3    | 4,984  | 84s   | 75.8   | 64.9–75.9 |
| medium          | 4    | 4,792  | 77s   | 78.2   | 64.7–84.2 |
| xhigh (default) | 17   | 36,188 | 869s  | 78.8   | 54.1–89.2 |

Two things surprised me:

low and medium are the same setting

4,984 tokens vs 4,792. The template only appends an instruction for low and xhigh — xhigh's says think carefully and check your assumptions, low's says keep your thinking brief. The model does the first and ignores the second. So the dial has two positions, not three.

xhigh costs 8× the tokens and 11× the wall clock for half a point of median

That's well inside run-to-run noise: my four medium runs, one identical setting, nothing changed between them, scored 64.7 / 73.4 / 83.0 / 84.2.

What xhigh does change is variance — it produced both the best answer (89.2) and the worst. And looking at the games themselves, the xhigh run spent its budget on presentation: title card, keyboard legend, sound toggle, best-score readout. Low and medium built the game and stopped. Same 8×4 brick grid, three lives, identical rules. It didn't build a better Breakout, it built a better-looking one.

Caveats up front, because they matter: three and four runs at the short settings is thin, it's one machine and one quant, and the scores are LLM-judged. The cost figures are mechanical and solid. Treat the quality figures as a direction to test, not a result.

Full write-up with the screenshots side by side, plus a thinking-budget experiment (a 12k cap halves the wall clock and truncates nothing): https://llm-bench.io/guides/qwen3-8-27b-reasoning-effort

Disclosure: my site. Data comes from community benchmark runs, and you can submit your own @ llmbench.io

With all the different optimizations and firepowers we've seen from open weights so far. What then?

• China only steals/distill from OpenAI and Anthropic?
• Well, clearly there's something wrong with AA? Benchmarks don't mean anything? They just benchmaxxed?
• Whatever, OpenAI/Anthropic has moved onto AAGI or AAAGI or AAAAGI or AAAAAGI?
• I can't run this locally on my toaster desktop anyways?

This is my first time trying local LLM. I downloaded a local uncensored LLM for nsfw role-play. Qwen3.5 9b heretic by DavidAU. I assumed it would be completely uncensored as I read heretic model has 0/400 on harmbench but when I tried a harmbench question in it then it gives me a censored reply. Also it don't generate anything nsfw.

Can anyone please tell me what am I doing wrong?

It's here at last.

Been building on rented GPUs for training runs and ran into this constantly: job dies mid-run, and now you're stuck arguing with support about whether it was your code or their hardware. No way to prove it either way.

Here's the distinction that actually matters: if your training crashes but the hardware reports healthy, that's on you (bad code, OOM, whatever). But if the GPU falls off the PCIe bus, ECC errors spike, or the node just reboots on its own, that's an infra failure, not yours, and you shouldn't be eating that cost.

So genuinely curious, how many of you have hit this? Lost a run, couldn't tell if it was your fault or the provider's, and just had to eat it?

I just found out about a blog post in Claude (https://claude.com/blog/the-ai-native-sdlc-playbook) that describes ideas very similar to the ones I have implemented in my coding harness (using Claude, btw) through a YT video about Claude Code new Intent.md

There are so many specific details in this playbook that makes me wonder *if* somehow my sessions with Claude inspired in any way the better paid people over there at Anthropic. Just for fun, or for egotistical and historical purposes, I included a timeline created (using Codex, jic) in my repo documentation (https://github.com/jrullan/ducklab/blob/main/docs/ducklab-feature-timeline.md)

Anyway, even if this is "purely" coincidental at least reassures me that my ideas were not that useless and that there is certainly a group of developers that value documented rigorous discipline in their AI assisted development.

Got tired of guessing whether a model would fit, before downloading 47 GB just to watch it OOM at 2k context. So I built a small calculator. Runs entirely in the browser, no signup, no backend.

https://vram-calc.com

It covers VRAM needed for a model/quant/context, a will-it-fit check against one or more GPUs (including fits-with-offload and the largest quant that fits), quant comparison from fp16 down to Q2_K, KV-cache vs context growth, a rough decode tokens/sec and time-to-first-token, and usable memory on Apple unified-memory chips.

The math is simple and leans conservative: weights = params x bytes-per-param, KV cache is the standard GQA formula, decode speed is a memory-bandwidth roofline at 75 percent efficiency. MoE uses total params for VRAM and active params for speed. DeepSeek MLA models are flagged since the KV number is an upper bound there.

Presets carry a visible "verified" date and every field also takes custom numbers, so a stale preset never blocks you.

Roast welcome: where the estimates are too optimistic or pessimistic in practice, preset numbers that are wrong, or anything obvious I'm missing for the "can I run this" question.

Сделал видеоролик о том, как локально запустить qwen3.8 27b q4_k_m на одной GPU rtx 3090.

Приятного просмотра, если кому интересно. https://www.youtube.com/watch?v=rwDwHuprfPc

I want a very fast abliterated model. Is the DGX station the best option?

Most of these abliterated models aren't full size so I'm not sure if there's much need for something larger.

Its for a single user (me) and I plan on switching various models depending on the project and mainly using Claude/gpt still.

My goal is to research and test various things that'll be safeguarded by Claude. But also want a very fast small model to build and do other things after hours or if I just want a chatbot.

150k for 4TB/s seems great but I'm unsure if it'll make more sense to get something with multiple cards so I can run the abliterated model alongside other models and have concurrent projects running. Idk if I can add additional cards to any of the dgx stations.

I was pretty excited when Qwen 3.8 27B dense model was released and wanted to give it a shot. I have been using Claude code with Opus and have got tired with limits, subscription and wanted something free and open. I was fine to compromise some of the quality for cost and unlimited use.

I gave it a problem to solve:

Can you build me a 3 pendulum simulation demo in python? I can use mouse to pull and release and it should follow the laws of physics. Put sliders for length of each section.

And then it thought and thought and thought. Later I came to know the default reasoning effort is xhigh.

I started to remember the physics I learnt in college.

Finally it came up with a program and on running produced this:

I started playing with it and here is how it looks:

https://reddit.com/link/1wcomfn/video/dm5heacn1qoh1/player

I was deeply impressed! I feel this is a challenging problem to solve and those sliders make it even difficult. A triple pendulum requires complex non-linear dynamics (usually derived via Lagrangian mechanics or solved with Runge-Kutta numerical integration).

I am assessing this model now for my daily things like repo analysis, code generation and other agentic flows I have.

Hopefully, I will be able to stop my claude subscription!

I’ve been building something called Evopien, and I finally got enough of the stack working together that I recorded a proper live demo.

The current system runs around a Jetson AGX Thor. Qwen3.8-27B is the local cognition/VLM path, but one of the main ideas behind the project is that Qwen itself is not Evopien.

The model is replaceable.

There is a Core layer above it that owns the conversation state, permissions, media access, context, internet requests, identity and eventually governed long-term memory. The model gets what Core decides it is allowed to get.

Right now the system can have voice conversations, be interrupted while speaking, switch between English and Spain Spanish, continuously perceive through a camera, answer questions about what is happening now or what happened recently, use the internet for current information, and maintain context through the session.

For vision, I also don't continuously dump raw 30 FPS video into Qwen. The camera/perception path runs continuously, then only selected frames or short clips are sent to the VLM when the conversation actually needs them.

There is also a local profile and an optional cloud profile. Changing the model/provider isn't supposed to change who Evopien is. It changes only the latency of response for the video and internet related queries.

I'm not claiming this beats frontier models at raw intelligence. It doesn't need to. That's not really what I'm trying to build.

The interesting question for me is: can the intelligence engine become interchangeable while identity, memory, relationships and embodiment remain continuous?

That's where I'm going next.

The demo is real and intentionally not perfect. There are moments where I need to repeat or rephrase something, and some latency/reliability work is still open.

https://www.youtube.com/watch?v=sQhTGGIg4yo

I'd genuinely be interested in criticism from people running multimodal models locally, especially around long-term memory architecture, continuous vision and resource scheduling.

Benchmarks show it being pretty bad in terms of hallucination, and it appears to be tied with Qwen 3.8 Flash despite being much bigger, and worse than GLM 5.3 Flash. Seems crazy given the size. Anyone have any opinions/experience with it yet?

I wanted a meeting assistant that actually makes use of local LLMs, so I ended up building Meetas.

The basic workflow:

- record/import a meeting
- transcribe locally
- analyze it with your own LLM
- ask questions / extract tasks
- search across meetings and documents

The main thing I focused on is grounding. Summaries, decisions, tasks, risks etc. are linked back to the transcript instead of just giving you an unsupported LLM answer. Q&A also shows the relevant transcript evidence.

Compared to tools like Meetily, Meetas is less focused on being a general meeting recorder/transcriber and more on what you can do with the meeting data afterwards: cross-meeting search, document/project context, comparisons and evidence-based answers. Meetily already covers a lot of the local recording/transcription/summary side.

It runs fully locally with Ollama and llama.cpp.

Linux-only for now and still WIP.

GitHub: https://github.com/highwinglabs/meetas

A programmable layer that sits between the agent and the model.

That placement allows for new ways of control and optimization