mkeeter

This is a clean separation, and clean separations are worth noticing. They tend to be load-bearing.

oh hi Claude

Does one also get dopamine from using LLMs to write comments on Hacker News?

A repository search shows 2.2K repos with the text "A Mini Shai-Hulud has Appeared", all created within the past day:

https://github.com/search?q=A%20Mini%20Shai-Hulud%20has%20Ap...

Cryptic Titles Are All You Need

Fair enough, I accept "the blog post was written by someone from the 1800s" as an alternative hypothesis.

edit: For what it's worth, I also just tested the Gettysburg Address (using the "Bliss Copy" from [1]), and got a "100% Human" score.

[1] https://www.abrahamlincolnonline.org/lincoln/speeches/gettys...

The review is also heavily LLM-inflected, to the point of being distracting.

GPTZero gives it a 100% chance of being AI generated, and I've found that these tools may give false negatives from a well-prompted model, but false positives are rare.

If you are looking to tune your intuition for AI-written text, here's an interesting list of their quirks (ironically provided as a Claude skill for removing those quirks from emitted text):

https://github.com/stephenturner/skill-deslop/blob/main/refe...

The "Intermediate Report" [1] lists the authors as "Robert V. and Claude (Anthropic)". Is there any reason to believe this is not AI hallucinations?

[1] https://stateofutopia.com/papers/2/intermediate-report.pdf

Congrats!

(We had one back in December; you’re in for a fun ride!)

They certainly have ambitions – the most recent changelog claims to add "Full PCB design pipeline: schematic capture, routing, DRC, Gerber export, and signal integrity simulation."

It also seems to have a physics engine, a slicer for 3D printing, an embroidery mode, and a entire ecosystem of math crates (https://tang.toys/).

Whether any of that works – or whether it's pure LLM slop – is less clear. I tried to import a trivial STEP file, and it crashed my browser tab [1]. Every commit is co-authored by Claude.

[1] https://github.com/ecto/vcad/issues/7

Not a typo, but you’re correct about the sample rate - with those settings, the scope was doing interpolation between samples.

More evidence: the user posted three well-formatted multi-sentence comments within 15 seconds.

https://news.ycombinator.com/item?id=47110801 (13:23:08)

https://news.ycombinator.com/item?id=47110803 (13:23:15)

https://news.ycombinator.com/item?id=47110804 (13:23:23)

I have received 168 support ticket emails in the past 30 mins, and Gmail has not yet learned to flag them as spam.

This is an absolute clown show.

Edit: whoops, this was incorrect! I had received over 1,000 Zendesk emails, 168 of which made it into my inbox.

Which NRTL did you end up using for certifications? Can you say more about that process?

oh hi ChatGPT

The giveaway is that LLMs love bulleted lists with a bolded attention-grabbing phrase to start each line. Copy-pasting directly to HN has stripped the bold formatting and bullets from the list, so the attention-grabbing phrase is fused into the next sentence, e.g. “Potential for abuse Attestation enables blacklisting”

https://mattkeeter.com

Lots of projects, ranging from embedded systems to DIY CAD software and GPU algorithms.

The publisher describes itself as “Fusion of Researcher and AI: Independent publisher of peer-reviewed research in post-biological epistemics“

Is there any reason to believe this isn’t an AI-assisted crank publication?

jj undo is great but it's a one time thing.

For what it's worth, this changed in v0.33.0:

jj undo is now sequential: invoking it multiple times in sequence repeatedly undoes actions in the operation log.

(release notes: https://github.com/jj-vcs/jj/releases/tag/v0.33.0)

(I work at Oxide, though I wasn't around for the initial chip selection process)

It's at least partially a matter of timing: Oxide was picking its initial hardware in roughly 2020, and the RP2040 wasn't released until 2021.

A handful of people have done ports, e.g. https://github.com/oxidecomputer/hubris/pull/2210, but I expect to stick with STM32s for the foreseeable future – we've got a lot to do, and they're working well enough!

The LLM tics are strong in this writeup:

"No manual overrides, no exceptions."

"Our VDP isn't just a bug bounty—it's a security partnership"

The server and switch hardware is designed in-house (from the PCBs on up), though we do source DRAM / SSDs / CPUs / ASICs from the usual vendors.

The "secret sauce management layer" is available at https://github.com/oxidecomputer/omicron, released under the MPLv2 license.

(I work at Oxide)

I'm not aware of folks outside the company running the whole control plane, but people have definitely gotten parts of the system running at home:

https://artemis.sh/2022/03/14/propolis-oxide-at-home-pt1.htm...

(The author of this blog post now works for Oxide!)

(OP here)

This is taken directly from the paper's introduction, which admittedly uses the more specific terminology of "1-Lipschitz signed distance bounds".

The paper cites the original Hart '96 paper on sphere tracing; quoth Hart, "a function is Lipschitz if and only if the magnitude of its derivative remains bounded".

https://graphics.stanford.edu/courses/cs348b-20-spring-conte...

I wonder if there's a terminology schism here between computer graphics and numerical analysis folks.

Interesting post, thanks for the link!

You may also enjoy "Spelunking the Deep: Guaranteed Queries on General Neural Implicit Surfaces via Range Analysis", which uses interval arithmetic (ish) to raymarch neural implicit surfaces:

https://arxiv.org/abs/2202.02444

What are the practical implications of this kind of assembly language? Surely there’s more efficient means of describing 2D SDFs?

By analogy, you wouldn't program in LLVM IR, but it's a useful intermediate representation for a bunch of higher-level languages. Higher-level tools can target this representation, and then they all get to use a standard set of optimizations and algorithms (fast evaluation, rendering, etc).

(I gave a recent talk that's a broad overview of this research: https://www.youtube.com/watch?v=UxGxsGnbyJ4)

My next thought would be to evaluate the program at a low resolution to create a low res SDF texture for the shader to draw at a higher resolution.

Glad you're enjoying the challenge! You may also be interested in

https://www.redblobgames.com/x/2403-distance-field-fonts/

Can anyone explain where this blob of "assembly language" comes from?

Assembly language is definitely the right analogy: it's a low-level target generated by higher-level tools. In this case, the expression came from a Python script calling this text(...) function:

https://github.com/mkeeter/antimony/blob/f6a56dd7/py/fab/sha...

The font is hand-built from geometric primitives (rectangles, circles, etc) and CSG operations (union, intersection, difference)

What is considered an acceptable preprocessing or transformation?

I'm looking for interesting ideas, and to mine the depths of PLs / compiler / interpreter / runtime research. Just returning a fixed image isn't particularly interesting, but (for example) I just updated the site with a compile-to-CUDA example that shows off the brute force power of a modern GPU.

Quoth the article: "Obviously, you could precompute the entire image, but that's against the spirit of the challenge"

By default mlua uses pkg-config tool to find lua includes and libraries for the chosen Lua version. In most cases it works as desired, although sometimes could be more preferable to use a custom lua library.

The fact that Rhai builds with just 'cargo build' shouldn't be underestimated - a Rust project with all pure-Rust dependencies is much easier to maintain / support / distribute across a wide variety of hosts!

This wouldn't be an issue if I locked my computer in a safe, but the rest of the system is changing underneath me: I may have a new laptop, a new CMake version, a new Qt install location, etc. Having everything managed through Cargo does a great job of isolating me from those kind of changes.

You would probably find "A Unified Differentiable Boolean Operator with Fuzzy Logic" interesting!

https://arxiv.org/abs/2407.10954

They build up CSG trees with differentiable leafs (quadrics) combined with differentiable boolean-ish operations, so you can hill-climb over the entire shape.

Here's a quick list, off the top of my head:

"Ao" was an early codename for libfive, so those are the same thing (at different stages of development).

Fidget is written in Rust, versus C/C++ for libfive. This makes it easier to use as a dependency (in Rust projects) and cross-compile to WebAssembly. Also, I don't have to debug segfaults anymore, except when touching the raw assembly in the JIT.

They both implement a similar set of algorithms (meshing, 2D and 3D rasterization).

Fidget has the potential to be faster due to its JIT, and is faster for 2D / 3D rasterization. (I suspect that the non-JIT interpreter is also faster at rasterization, for architectural reasons)

libfive has more effort put into its meshing algorithms, so it does a better job of handling edge cases (heh). I've heard reports that libfive is faster than Fidget at meshing, but haven't done much investigation.

Fidget is not limited to 2D and 3D functions: it can be used wherever you want to quickly evaluation graphs of math, with arbitrary numbers of inputs and outputs. libfive, on the other hand, is specialized to functions of the form f(x, y, z, *vars) -> v.

Extremely in the weeds: if you know what libfive's "feature"-flavored evaluator is, Fidget doesn't have it.