merksoftworks

Nor are the victims of preventable disease to be blamed for being born into countries without functioning governments. I'm happy to pay $37 as a U.S. taxpayer if it saves the life of someone I'll never meet.

Very! there are unified headers and a C library that the maintainers have written as a wrapper around the library.

https://github.com/gfx-rs/wgpu-native

https://github.com/eliemichel/WebGPU-Cpp

in oh-my-zsh you can use `take` to do what mkcd does.

Agreed. I wish it was easier to embed the compiler in my favorite languages and reflect on it. Quite excited bout Wesl: https://github.com/wgsl-tooling-wg/wesl-rs.

I dug around on this web page and found outlinks to:

The "Stop Gangstalking Awareness Group", and especially this page about "Understanding Neuro Weapons." LaserPointerSafety has not evaluated the accuracy or usefulness of this group or their information. (Thanks to M.D. in July 2024 for bringing this to our attention.)

These are kind of kooky links: https://web.archive.org/web/20240509210655/https://stopgangs...

This has been posted here a while ago but I'm pretty excited about bolt: https://github.com/Beariish/bolt - I've been looking for a statically typed language which could integrate well around something with a strong type system and good meta programming facilities for generating bindings. Bolt has the benefit of being a pretty small library with the downside of being nascent.

What I will say about sycophancy - the recent rollback that OpenAI went through does appear like a clear attempt to push the envelope on dark patterns wrt AI Assistants. Engagement optimized assistants, pornography, and tooling are inherently misaligned with the productivity or wellbeing of their users in the same way that engagement maximized social media is inherently misaligned with the social wellbeing of it's users.

This is a misquote - the two minutes of context around the content he was commenting cause it to make way more sense: https://www.youtube.com/watch?v=ngZ0K3lWKRc

He's right that to someone who's art is about capturing the world through a child's eyes, the dreamlike consonance of everyday life with simple fantasy, this is abominable.

So, gingerol is anti inflammatory. Fun fact, so is allicin, which is produced by garlic. You get a lot of medicine that looks quite a bit like quack medicine - for instance people making garlic extract: https://www.allicin-c.com/?AFFID=549212

But then you end up with peer reviewed studies which indicate some anti-viral properties of garlic: https://pmc.ncbi.nlm.nih.gov/articles/PMC7434784/

This is the direction i've been theoretically harping about to all my friends, API first creative software will win out. After Effects has a decent JS api, Da Vinci Resolve has python and lua, you can script your way to a decent starting point with any of these tools. They even have well featured rollback for transactions committed during scripting. We need a generic MCP for the scripting environments in many desktop apps, screen capture for ones which take multimodal input.

This is really cool but it's not portable to MacOs or aarm64 yet, and that kind of portability unfortunately is what appeals to me about an embeddable scripting language.

My experience has been more like this: - Write small library as contract work. - Client vibe codes with it. Code doesn't work. - End up doing good faith assurance work to fix the vibe coded bug in the client code, the issue was not in my small library.

People are programming out on a limb - and blame goes to the library maintainer if the user lacks the fundamental skills to do troubleshooting.

I think the borrow checker doesn't get enough credit for supporting one of rusts other biggest selling points - it's ecosystem. In C and C++ libraries often go through pains to pass as little allocated memory over the API barrier as possible, communicating about lifetime constraints and ownership is flimsy and frequently causes crashes. In Rust if a function returns Vec<Foo> then every Foo is valid until dropped, and if it's not someone did something unsafe.

I love this sort of thing. I wish there were a better alternative for ISF[1], it's quickly showing it's age. The kind of GPU sand boxed graph construction that this enables would be really powerful with the right "linker". I'm thinking about drafting a proposal for wesl[2] to have a more ergonomic reflection and metadata system to make this kind of quick and scrappy pipeline construction feel first class in shader tooling. Slang has something like this, so does GDShader and the shader tooling for unity.

[1]: https://isf.video/ [2]: https://github.com/wgsl-tooling-wg/wesl-rs

SEEKING WORK | Location: Bay Area / Remote

I Run a small contracting group, we have a few floating designers and devs of various backgrounds. We love creative work and hard technical problems. Our site doesn't list all of us at the moment.

Technologies: Rust, C/C++, Web (multiple backend, multiple frontend), Swift, Many graphics API's, adobe SDKs, python, databases, devops, godot, ecommerce, radare2 etc.

Website: https://www.merkatoria.com/

Some of the QT people have forked off and started working on slint[1], iced[2] is the most mature gui in the rust ecosystem right now (in my opinion), but still lacking in some ways, including portability to mobile and component libraries are sort of against the design principle so it's allergic to network effects. Iced is built on some pretty orthodox elm architecture principles by some very talented and devs - but they leave very little room for impurity.

[2] https://iced.rs/ [1] https://slint.dev/demos

So egui is great for projects where the application runtime is short lived, or for overlays in longer lived projects. The visual equivalent of scripts, where you know you need a small amount of immediate visual feedback and tweaking parameters for it to be useful to the end user.

Flutter answers questions about more robust UI.

It's good that you chose the right tool for the job and more people should know that there are options. But fundamentally I'm most motivated by the possibility of a robust UI framework made from first principles to be as low friction as egui but with the accessibility, performance, and visual flexibility of stylable retained mode guis.

Raph Levien and the xilem project might be getting us closer.

I think my main use case would be to run it on unit tests, and then to provide a human-in-the-loop way to slowly hydrate small to medium sized code bases with types. Maybe progressive refactor tools aren't something anyone actually wants to use or maintain, because I just don't see them around that much.

I'd like to experiment with writing a reflection based dynamic type annotator for one of these. Just as a toy. Imagine a module which monkey patches every function, class in the parent module it is loaded into, then reflects on the arguments at run time slowly building up a database of expected type signatures. The user would then pick through the deltas approving what made sense.

In the long run %100. comparing the lowest quartile of high school grads to the lowest quartile of college grads, the college grad makes about $30k more. So without accounting for interest on the loans (if they were needed) it would take about ~13 years to pay for itself, 17 if you count the four years it took to get the degree. At the upper quartile it looks more like five or six years to pay for itself. Please correct my napkin math or my napkin source if this seems shaky: https://www.ppic.org/publication/is-college-worth-it/

pde5 inhibitors have some dangerous interactions other medications. They also give some people headaches, up to and including migraines. I agree, they will probably end up in some techies nootropic stacks in the near future, I would use them for that. But they can cause blood pressure issues.

That's how ye' get yerself Tzeench'd

ffmpeg has always felt like a gui application crammed into tui format. I've had the displeasure of using the C api a few times, while it's straight forward in many respects, it makes invalid states extremely easy to represent. I would love a realtime AV1 encoding framework that "just works".

Technical art is definitely my first love in software. I'm excited for godot to add an easier compute shader pipeline for post processing effects - their current compositor plugin set up is a bit boiler plate intensive.

this repo is a great example of post processing in godot: https://github.com/sphynx-owner/JFA_driven_motion_blur_demo

I have a use case for slang, I want to use it to transpile user provided shaders to WGSL and then use it's custom user attributes to provide metadata for setting up composable image processing shaders with minimal developer intervention, like shader toy or compute toy. The thing that is making this annoying is that the tooling is very bound to C++. Has anyone found a good rust wrapper for slang?

It's not just a spir-v frontend, it also transpiles to other shader languages.

Rusts current pretty printers in lldb and gdb are just not good enough for a fluid step debugging experience. I've had luck with intellij IDE's but it's very sad that the best we can do in a language with such good devex tooling is print debugging.

Theoretically you could generate debug scripts with a macro and embed them with

  #![debugger_visualizer(gdb_script_file = "../foo.py")]

but I haven't seen anyone go through the trouble.