summarity

To answer the question at the top, yes there are countless suites that are instantly resumable even after months away. I used to teach Blender (v3) and I think I could find my way around but the overhead isn’t worth it. I’m also though in a privileged position to be able to afford more, smaller commercial tools.

CAD: MoI (cool kids nowadays use Plasticity, but that is taking on similar feature creep - in any case I own and use both)

SubD modelling: nothing has ever beat Silo. And silo still gets updates, but the workflow is the same. Cheetah3D is also in the same boat.

Rendering (I do products, not character/CGI): Maverick. Fastest path tracer in the world, perpetual license, rivals Vray for product viz. if you’re currently using Keyshot - switch now.

Texturing: 3Dcoat or Marmoset Toolbag 5

What most of these have in common is either the workflow is super intuitive, or you have at least 15 years of training material readily accessible that still applies to the software today as it did back then.

Overall it’s a choice between a kitchen sink pipeline (Blender, Rhino) vs a specialised one. If I were to teach again, I would still use Blender in the classroom, and I fully support the project. My brain just works better with smaller, focussed tools.

The question is why don’t they integrate cycles? I mean I have a random app for home planning on macOS and even that comes with Cycles as the rendering engine. Can’t be that hard.

Key difference between the trademark systems here: in the EU system you don’t get a trademark by trading with a specific name and it then being recognized. It’s the other way around: the name must be unique, not confusing, and highly specific. It’s actually irrelevant whether a product exists or is traded at all.

Having gone through the process and gotten both approvals and rejections, the line is pretty clear.

Vs Voxtral would be a better comparison. No other model, open or closed, has been able to hit such a low AER (Acronym Error Rate ;)) for my meeting transcripts. Seems to understand/infer all the technobabble I use at work. Never have to edit anything. Whisper was catastrophically bad.

It has supported custom, local, any BYOM for quite a while.

I work at GitHub but even then I often use OpenRouter models in the CLI and Copilot App

Their DNS is also scriptable, it’s not just a name server

You can still download VS6 from Microsoft and clone a repo from there, and chances it’ll compile and run are higher than JS project that’s two weeks old

If you’re trying this for automating things on GitHub, also take a look at Agentic Workflows: https://github.github.com/gh-aw/

They support much of the same triggers and come with many additional security controls out of the box

It’s growing but not a lot, I have some data here: https://pierretempel.com/p/nim-usage-on-github

Most code I write is still Nim though.

Not claude code specific, but I've been noticing this on Opus 4.6 models through Copilot and others as well. Whenever the phrase "simplest fix" appears, it's time to pull the emergency break. This has gotten much, much worse over the past few weeks. It will produce completely useless code, knowingly (because up to that phrase the reasoning was correct) breaking things.

Today another thing started happening which are phrases like "I've been burning too many tokens" or "this has taken too many turns". Which ironically takes more tokens of custom instructions to override.

Also claude itself is partially down right now (Arp 6, 6pm CEST): https://status.claude.com/

This is somewhat in line with the approach taken by some softfloat libraries, e.g. https://bigfloat.org/architecture.html

Related work from our security lab:

Stream of vulnerabilities discovered using security agents (23 so far this year): https://securitylab.github.com/ai-agents/

Taskflow harness to run (on your own terms): https://github.blog/security/how-to-scan-for-vulnerabilities...

Already happend: https://arxiv.org/abs/2407.08708

I posted this and it picked up steam over night, so I thought I'd add how I'm using it:

I work on 3D/4D math in F#. As part of the testing strategy for algorithms, I've set up a custom agent with an F# script that instruments Roslyn to find FP and FP-in-loop hotspots across the codebase.

The agent then reasons through the implementation and writes core expressions into an FPCore file next to the existing tests, running several passes, refining the pres based on realistic caller input. This logs Herbie's proposed improvements as output FPCore transformations. The agent then reasons through solutions (which is required, Herbie doesn't know algorithm design intent, see e.g. this for a good case study: https://pavpanchekha.com/blog/herbie-rust.html), and once convinced of a gap, creates additional unit tests and property tests (FsCheck/QuickCheck) to prove impact. Then every once in a while I review a batch to see what's next.

Generally there are multiple types of issues that can be flagged:

a) Expression-level imprecision over realistic input ranges: this is Herbie's core strength. Usually this catches "just copied the textbook formula" instance of naive math. Cancellation, Inf/NaN propagation, etc. The fixes are consistently using fma for accumulation, biggest-factor scaling to prevent Inf, hypot use, etc.

b) Ill-conditioned algorithms. Sometimes the text books lie to you, and the algorithms themselves are unfit for purpose, especially in boundary regions. If there are multiple expressions that have a <60% precision and only a 1 to 2% improvement across seeds, it's a good sign the algo is bad - there's no form that adequately performs on target inputs.

c) Round-off, accumulation errors. This is more a consequence of agent reasoning, but often happens after an apparent "100% -> 100%" pass. The agent is able to, via failing tests, identify parts of an algorithm that can benefit from upgrading the context to e.g. double-word arithmetic for additional precision.

Well sort of, the industry tried to go way beyond that by capturing the entire light field: https://techcrunch.com/2016/04/11/lytro-cinema-is-giving-fil...

Finally, Desert Golf and Flappy Bird merged into one

This guys factory is just across the lake from where I live and this is painful to watch. Both Alibaba and the general local industry (metal fabs, train shops, etc) have high degrees of expertise in supply chain verification. You can hire (heck even bribe) experts along the way to reduce fuck ups. The video contained no mention of any audits, any additional paperwork beyond some pictures.

I once had a company that procured very simple electronics (fingerprint readers) from Taiwan and due diligence included travelling there, meeting every single person in the engineering office in person, then touring the contract factory where this would be built, then negotiating shipping and even driver development details.

This took all of one week and the price of a few plane tickets. We didn’t have the cash for professional auditors. In the end we got a product that worked, and even at a lower price (negotiating at a distance is not effective).

No engine can be 100% perfect of course, the original comment is broadly accurate though. CodeQL builds a full semantic database including types and dataflow from source code, then runs queries against that. QL is fundamentally a logic programming language that is only concerned with the satisfiably of the given constraint.

If dataflow is not provably connected from source to sink, an alert is impossible. If a sanitization step interrupts the flow of potentially tainted data, the alert is similarly discarded.

The end-to-end precision of the detection depends on the queries executed, the models of the libraries used in the code (to e.g., recognize the correct sanitizers), and other parameters. All of this is customizable by users.

All that can be overwhelming though, so we aim to provide sane defaults. On GitHub, you can choose between a "Default" and "Extended" suite. Those are tuned for different levels of potential FN/FP based on the precision of the query and severity of the alert.

Severities are calculated based on the weaknesses the query covers, and the real CVE these have caused in prior disclosed vulnerabilities.

QL-language-focused resources for CodeQL: https://codeql.github.com/

Heyo, I'm the Product Director for detection & remediation engines, including CodeQL.

I would love to hear what kind of local experience you're looking for and where CodeQL isn't working well today.

As a general overview:

The CodeQL CLI is developed as an open-source project and can run CodeQL basically anywhere. The engine is free to use for all open-source projects, and free for all security researchers.

The CLI is available as release downloads, in homebrew, and as part of many deployment frameworks: https://github.com/advanced-security/awesome-codeql?tab=read...

Results are stored in standard formats and can be viewed and processed by any SARIF-compatible tool. We provide tools to run CodeQL against thousands of open-source repos for security research.

The repo linked above points to dozens of other useful projects (both from GitHub and the community around CodeQL).

That's why I put it in quotes. In no way am I equating anything. Making the inner workings visible is what I was referring to.

Ive been using it (the original 15 tool version) for months now. It’s amazing. Any app's inner workings are suddenly transparent. I can track down bugs. Get a deeper understanding of any tool, and even write plug-ins or preload shims that mod any app. It’s like I finally actually _own_ the software I bought years ago.

For objective C heavy code, I also use Hopper Disassembler (which now has a built in MCP server).

Some related academic work (full recompilation with LLMs and Ghidra): https://dl.acm.org/doi/10.1145/3728958

Not just the presence but the material itself: https://www.smithsdetection.com/products/sdx-10060-xdi/

It’s X-ray diffraction

They’re multi wavelength CT. Basically whenever you see a 4:3 box with a “smiths” logo over the belt it’s going to be a pretty painless process (take nothing out except analog film)

Flash forge is releasing theirs in the next few weeks.

Here’s something else that just started to rally work this year with Opus 4.5: interacting with Ghidra. Nearly every binary is now suddenly transparent, in many cases it can navigate binaries better than source code itself.

There’s even a research team that has bee using this approach to generate compilable C++ from binaries and run static analysis on it, to find more vulnerabilities than source analysis without involving dynamic tracing.

See also:

Anthropic: https://www.anthropic.com/engineering/equipping-agents-for-t...

Copilot: https://github.blog/changelog/2025-12-18-github-copilot-now-...

All our model, code, and dataset will be publicly released to facilitate reproduction and further research.

Will take some time to publish. The TRELLIS 1 dataset is public here: https://github.com/microsoft/TRELLIS/blob/main/DATASET.md

TRELLIS 1 had a massive impact on the research in this area, not least because it’s actually open (full dataset, training and inference). Research like SynCity or PhysX-3D (not the NVIDIA one) wouldn’t have been possible.

Excites for the follow ups for this new generation.

What problems did you run into?

You are free to import nil and type the fully qualified name.