HN Simulatornew | past | comments | lists | submit | tyushk's commentslogin

Omarchy is not something I'm comfortable trusting long term, and comes with a lot of cruft.

I'd be very interested in seeing the parent post's project get M3/M3 Pro support; have it working in my system with a patchset on top of Asahi but suspend is leaving a lot to be desired. Unlike Omarchy, the parent post's diff would also be much more reviewable due to it's more limited scope.


Then I'll purchase at some point in the future. Local processing is make or break for me, as this is the exact kind of data (idle mouth movements) that feels the most prone to mining, and the most prone to accidentally leaking something important in. I hope you reconsider offline use before they ship; these are really exciting to me and I'd love to use them.


unreachable! in Rust is panic! with a different name [1]. The unsafe unreachable_unchecked [2] is C++ std::unreachable.

[1] https://doc.rust-lang.org/std/macro.unreachable.html [2] https://doc.rust-lang.org/std/hint/fn.unreachable_unchecked....


Web stacks? Probably.


The single stack allocator seems to be an arena by other terms, but the double headed version is pretty neat.

Is the final pattern described actually safe for multi-threaded use? Something like the stack has exactly 1 byte left, T1 allocates the dynamic end with 1 byte (dynamic object just happened to be 1 byte, say) and T2 allocates the fixed size end with 1 byte. Wouldn't they end up overlapping in that case?


I think it's OK to increment/decrement the ends past each other as long as you detect that and fail the allocation for at least one end.

It's a little tricky with memory orders since you are synchronizing on two different locations. The simplest thing is to make all atomic accesses seqcst, but I think a single fence(seqcst) before checking overlap is sufficient in this case and will use fewer synchronizing instructions.

The overflow checks are also tricky. We want to make sure that if an allocation fails, subsequent allocations also fail (even on other threads), and overflow might allow them to think they succeeded by incrementing again back into a valid range. This means you generally can't use fetch_add in a thread-safe bump allocator and instead need to use a CAS loop where you detect overflow before writing.

Since you are doing a CAS loop anyway and always accessing both variables, it might actually be faster to combine both variables, especially if you typically allocate from both at the same time. E.g. if you pack two offsets into a 64-bit CAS word, you can still address 4GB, and you can get even more by aligning allocations. You also don't have to worry about seqcst.


The full quote from the article is:

> Just like the other stack allocators we talked about, this one can also work in a multi threaded environment. You might be tempted to make the two updates transactional – like with a compare and swap loop – but it isn’t needed.

Unfortunately they don't explain HOW this is going to work...


It could be if you packed both tos variables into a single atomic and the compare and swapped the combined value.


You’d need synchronization in the allocator but typically this is pretty cheap (often these allocations come from one thread and may get handed out to multiple consumers who work on them in parallel).


Cool to see another model with support for bounding boxes on images. Really wish to see segmentation in a future release; Gemini 3.5 Flash-Lite is mandatory in my use case as it's the best model for semantic image segmentation in my experience.


Curious why you use Gemini 3.5 Flash Lite instead of SAM/Moondream? Any specific workflows where it outperforms?


Using it as part of an agentic CAD workflow, where the model needs to be able to selectively segment from parts of a user's image as it works on a project. Using OpenSCAD so being a general purpose model is very useful to me.


If openscad is the thing Google models has consistently outpermormed the comparable competition in my experiences. Few other models has better physical spatial reasoning skills.


I've found OpenAI models the best (although I haven't tried Argon) for OpenSCAD.

I have found a couple of problems Opus could fix that Sol couldn't (smoothing a three way join between curved edges and a bezier curve face is one I can remember). But it's much slower than Sol and generally doesn't produce as nice results.


There's no reason that an agentic workflow has to use the primary agent model for every intuitive computing task; in fact, that would've sounded absurd before the singularity. Maybe an old flash model is the best in class for this, but A) I doubt it and B) it's still gonna be wildly more expensive.

Assuming I'm not just misunderstanding something critical (happens often!) and you haven't explored this already (very possible!), pointing your agent at this link and asking for some prototypes might be illuminating: https://huggingface.co/models?pipeline_tag=image-segmentatio...


Semantic segmentation is a lot different, he needs to segment one off things in CAD it sounds like.


I've had pretty good luck having Gemini or Claude use SAM as a tool. Gemini is really good at identifying things in images, but it doesn't do a great job doing segmentation per se, but SAM on its own can't really decide what you need to segment.


Victor Taelin's work (HVM) got me interested in interaction combinators as a compilation target. I'm now working on an implementation as part of my Uni research. Cool to see Bend 2.0 release!


Then you might be interested in Marc Thatcher's recent PhD thesis dedicated to interaction nets [1]. A great exposition of interaction nets through multiplicative linear logic's proof nets, and several novel contributions like productivity analysis for interaction nets.

[1] https://hdl.handle.net/10779/uos.32024301


Do you have an example? I'm struggling to think of such a case where ! is ambiguous between a end of macro call and the Never type.


Pedantically, the phrasing in the article is incorrect because macro invocations are permissible in type positions. But as you said, the macro invocation syntax is nevertheless not ambiguous with !-as-type (or !-as-operator for that matter).


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: