cmdr2

If you as a person outsourced your thinking than it's you who will suffer.

Using a code generator != outsourcing your thinking. I know that's the popular opinion, and yes, you can use it that way. But if you do that, I agree you'll suffer. It'll make sub-optimal design decisions, and produce bloated code.

But you can use code generators and still be the one doing the thinking and making the decisions in the end. And maintain dictatorial control over the final code. It just depends on how you use it.

In many ways, it's like being a tech lead. If you outsource your thinking, you won't last very long.

It's a tool, you're the one wielding it, and it takes time, skill and experience to use it effectively.

I don't really have much more to say. I just spoke up because someone who built something cool was getting beat up unnecessarily, and I've seen this happen on HN way too many times recently. I wasn't pointing fingers at you at any point, I'm glad to have had this discussion :)

this is presumably a 16k loc project that was commited in a single commit two days ago. So the author never commited any draft/dev version in the time

It's quite common to work locally and publish a "finished" version (even if you use source control). The reasons can vary, but I highly doubt that Google wrote Tilt Brush in 3 commits - https://github.com/googlevr/tilt-brush

All I'm saying is assuming everyone one-shots code (and insulting them like people do on HN), is unnecessary. I'm not referring to you, but it's quite a common pattern now, counter to HN's commenting guidelines.

found AI-like comments in the code

Sure, but respectfully, so what? Like I posted in a [separate comment](https://news.ycombinator.com/item?id=47057690), code generators are like power tools. You don't call a carpenter sloppy because they use power tools to drill or cut things. A sloppy carpenter will be sloppy regardless, and a good carpenter will obsess over every detail even if they use power tools. A good carpenter doesn't need to prove their worth by screwing in every screw by hand, even if they can. :)

In some cases, code generators are like sticks of dynamite - they help blow open large blocks of the mountain in one shot, which can then be worked on and refined over time.

The basic assumption that annoys me is to assume that anyone who uses AI to generate code is incompetent and that their work is of poor quality. Because that assumes that people just one-shot the entire codebase and release it. An experienced developer will mercilessly edit code (whether written by an AI or by a human intern), and edit it until it fits the overall quality and sensibility. And large projects have tones of modules in them, it's sub-optimal to one-shot them all at once.

For e.g. with tests, I've written enough tests in my life that I don't need to type every character from scratch each time. I list the test scenarios, hit generate, and then mercilessly edit the output. The final output is exactly what I would've written anyway, but I'm done with it faster. Power tool. The final output is still my responsibility, and I obsessively review every character that's shipped in the finished product - that is my responsibility.

Sure plenty of people one-shot stuff, just like plenty of Unity games are asset flips, and plenty of YouTube videos are just low-effort slop.

But assuming everything that used AI is crap is just really tiring. Like [another commenter said](https://news.ycombinator.com/item?id=47054951), it's about skilled hands.

something that the original author did not even bother to write

Again, this is an assumption. If I give someone bullet points (the actual meat of the content), and someone else puts them into sentences. Did the sentences not reflect my actual content? And is the assumption that the author didn't read what was finally written, and edit it until it reflected the exact intent?

In this case, the author says they used AI to generate the ASCII art in question. How does that automatically mean that the author AI-generated the entire readme, let alone the entire project? I agree, the knee-jerk reactions are way out of proportion.

Where do you draw the line? Will you not use grammar tools now? Will you not use translation tools (to translate to another language) in order to communicate with a foreign person? Will that person argue back that "you" didn't write the text, so they won't bother to read it?

Should we stop using Doxygen for generating documentation from code (because we didn't bother with building a nice website ourselves)?

Put simply, I don't understand the sudden obsession with hammering every nail and pressing every comma by hand, whereas we're clearly okay with other tools that do that.

Should we start writing assembly code by hand now? :)

For what it's worth - for people who're in this space - this project is awesome, and I hope you keep going with it! The compiler space for GPUs really needs truly open-source efforts like this.

Code/doc generators are just another tool. A carpenter uses power tools to cut or drill things quickly, instead of screwing everything manually. That doesn't mean they're doing a sloppy job, because they're still going to obsessively pore over every detail of the finished product. A sloppy carpenter will be sloppy even without power tools.

So yeah, I don't think it's worth spending extra effort to please random HN commenters, because the people who face the problem that you're trying to solve will find it valuable regardless. An errant bold or pipe symbol doesn't matter to people who actually need what you're building.

This is obvious AI slop from the readme

I keep hoping that low-effort comments like these will eventually get downvoted (because it's official HN policy). I get that it's fashionable to call things AI slop, but please put some effort into reading the code and making an informed judgment.

It's really demeaning to call someone's hard work "AI slop".

What you're implying is that the quality of the work is poor. Did you actually read the code? Do you think the author didn't obsessively spend time over the code? Do you have specific examples to justify calling this sloppy? Besides a misaligned "|" symbol?

And I doubt you even read anything because the author never talked about LLMs in the first place.

My beef isn't with you personally, it's with this almost auto-generated trend of comments on HN calling everyone's work "AI slop". One might say, low-effort comments like these are arguably "AI slop", because you could've generated them using GPT-2 (or even simple if-conditionals).

Google is acting here as the owner and maintainer of a services ecosystem... they increasingly experience difficulty to contain issues within that ecosystem and prevent them from spreading (piracy, malware, hacking,...)

I wonder if the smartphone app industry is big enough now that allowing just two corporates to govern them is no longer fair or democratic.

It has outgrown the "ecosystem" word a long time ago. It's a genuine industry now.

Apps are such a fundamental part of most people's lives now (whether they like it or not), and these two companies have a disproportionate amount of power over an entire industry.

https://pypi.org/p/torchruntime might help here, it's designed precisely for this purpose.

`pip install torchruntime`

`torchruntime install torch`

It figures out the correct torch to install on the user's PC, factoring in the OS (Win, Linux, Mac), the GPU vendor (NVIDIA, AMD, Intel) and the GPU model (especially for ROCm, whose configuration varies per generation and ROCm version).

And it tries to support quite a number of older GPUs as well, which are pinned to older versions of torch.

It's used by a few cross-platform torch-based consumer apps, running on quite a number of consumer installations.

I'm trying to understand this topic more, so I'm curious what you mean by the word tracking. I searched around, and wanted to check if my understanding is roughly correct:

Is tracking when the frequency data of the instrument, and the frequency+tempo changes in the music track are stored? And does midi just say "guitar" or "piano" and leave it up to the software to decide what those instruments sound like? So tracking would always reproduce the same sound, while midi can vary, even if it's making the same tones?

For e.g. an acoustic guitar and an electric guitar might both be producing a note at a particular base frequency (e.g. C2) but the overtones and amplitudes of those overtones would be completely different, giving each instrument their particular sound. So does tracking record that overtone distribution for each instrument, to ensure an acoustic guitar sounds like an acoustic guitar (that the music composer wanted)?

This is the source that I was reading - https://scalibq.wordpress.com/2017/03/29/trackers-vs-midi/

If not, I'd really appreciate any other reading material to understand what you mean by tracking, thanks!

People do use VR for modeling/animation in Blender - https://freebirdxr.com (disclaimer: I'm the author of this plugin)

Freebird is still quite basic, but it's under active development and more modeling and posing features are being added.

So a core set of people definitely use VR in Blender for creation/editing, but I agree the number is quite small.

Here you go - https://pastebin.com/raw/dGP6W1m1 (story courtesy ChatGPT). Fed your comment into it, and got this story.

It runs locally if you download the "m" and "l" files alongside it (for maps and models), and run it on a localhost server (to fix the CORS errors).

curl "https://phoboslab.org/q1k3/index.html" > index.html

curl "https://phoboslab.org/q1k3/l" > l

curl "https://phoboslab.org/q1k3/m" > m

python -m http.server

--

I then zipped it up, and converted that zip file to 7 QR codes, so technically yes, we can fit Quake on a few QR codes.

Yeah, I assumed it was made by Comfy's author, as maybe a next evolution of their project. I was feeling happy for them.

But since it's not made by Comfy's author, it's definitely not cool to name your project by using their name.

Easy Diffusion (previously cmdr2 UI) can run SDXL in 768x768 in about 7 GB of VRAM. And SDXL 512x512 in about 5 GB of VRAM.

Regular SD can run in less than 2 GB of VRAM with Easy Diffusion.

1. Installation (no dependencies, python etc): https://github.com/easydiffusion/easydiffusion#installation

2. Enable beta to get access to SDXL: https://github.com/easydiffusion/easydiffusion/wiki/The-beta...

3. Use the "Low" VRAM Usage model in the Settings tab.

Thanks! :)

Hi, I'm the author of the cmdr2 UI and installer (that iFire linked to). I'd be happy to contribute the 1-click installer used by my project. It's a battle-hardened installer (over 100k installations on all kinds of PCs and networks), and I'm finishing up a rewrite in python, so that the installer code is easier to maintain for others.

I'd be happy to submit a PR to your project, if you're interested in using it. I actually got it working with your project a few weeks ago, so I know it works with your repo.

I've opened a github issue as well, so we can talk there if you'd like: https://github.com/invoke-ai/InvokeAI/issues/1042

Like I mentioned elsewhere, https://github.com/cmdr2/stable-diffusion-ui is pretty popular, and is a 1-click installer for Win and Linux (Mac coming soon). Quite a lot of features, and well-liked by users for its easy-to-install and user-friendly GUI.

https://github.com/cmdr2/stable-diffusion-ui is pretty popular, and is a 1-click installer for Win and Linux (Mac coming soon). Quite a lot of features, and well-liked by users for its easy-to-install and user-friendly GUI.

There's a 1-click installation for installing Stable Diffusion locally (Windows/Linux), doesn't require anything pre-installed - https://github.com/cmdr2/stable-diffusion-ui#installation

Hi, there are a couple of good UIs. https://github.com/cmdr2/stable-diffusion-ui is an easy-to-install and use tool, written by me (with contributions by many). Version 2 is in beta, which is a 1-click installer for Windows, no dependencies or command line needed. v2 beta: https://github.com/cmdr2/stable-diffusion-ui/tree/v2

https://github.com/hlky/stable-diffusion is another popular and good tool.

Thanks! This worked for me finally. The conda approach suggested elsewhere was getting too complicated, and wasn't working properly (for me).

I built a simple UI around this, which installs Stable Diffusion's docker image, and lets you play with it locally in a browser-based UI. https://github.com/cmdr2/stable-diffusion-ui

You can try https://github.com/cmdr2/stable-diffusion-ui . It installs Stable Diffusion to your local computer, and provides a simple browser-based UI for playing with it. No need to mess with conda and other environment settings.

End of Bill Gates in the driver's seat, for better or for worse.

Building a VR-based 3D modeling software - https://me.cmdr2.org/freebird3d

Having fun delving into 3D algorithms that I've always wanted to learn, but felt too intimidated by all these years (still do).

Nice, I hadn't come across Bevy, thanks for mentioning this. For others: https://bevyengine.org/news/introducing-bevy/

This worked better for me too, so far. But it may depend on what the OP is working on. I'm in a similar situation as the OP, and asked people I know if they know anyone in the target or related fields. And then further asked those people if they knew anyone, at the end of the call. I'm still in the middle of this process right now, so let's see how it goes.

I don't ask if they think my product is a good idea. I ask questions about how they work, delve deep into the mundane details of their work, understand what the challenges are. Finally I make my own assessment of whether my product will truly be valuable to them. I do plan on pitching to some of them later, once I've a fairly good understanding of how my target users work.

Importantly, I was clear with everyone (including my friends) that I wasn't selling or pitching anything, and that my goal was to understand how the target users work. The product idea I have is just the context explained in the first 2-3 mins, the rest of the call is just listening and understanding their workflow. The conversations usually tend to be 30 mins to 1 hr.

+100 for 'Four Steps to the Epiphany'. All of what I did above was lifted straight from that book. I've been internalizing it for years, and still fail to follow it properly. It's an amazing book :)

The Prepared, by Spencer Wright. Weekly email digest of really interesting things from the world of engineering and manufacturing. https://theprepared.org/

Yes it would. But pure static generation tools like Hugo are really fast. In my case, it was regenerating ~1000 articles in about a second, while doing it with wordpress was nearly 25 minutes.

If it helps, I automated those steps into a simple tracker form: http://me.cmdr2.org/starlink/ will let you find when Starlink will pass over your selected city.

This is using the exact same approach that many redditors said worked for them, but does the data-crunching for you. It's a modified version of the tool you linked to (Jen Satre's excellent satellite calculator), and hardcodes the Starlink data.

I tried this last year for a Wordpress blog with ~1000 articles, and the time to generate the static pages was too long (several minutes) even for routine tasks like adding a new article. Simple things like a "New Articles" list in the sidebar can cause all pages to regenerate. I tried many different approaches (recursive wget, wordpress plugins, intercept wordpress output in PHP with ob_start() etc).

Ultimately, putting a Varnish cache seemed like the only logical answer to speed things a bit more, but that didn't avoid Wordpress security attacks.

For fun though, I built an experimental wordpress-clone dashboard that saved Hugo-compatible files instead, so I wouldn't miss Wordpress' editing features. The result was superb (<5 seconds to regenerate the ~1000 articles blog), but I missed the Wordpress plugins too much to switch to Hugo entirely.

But I still agree with you: "keep wordpress' editing experience, but generate static sites" is a pretty promising direction IMO.

I think so too but couldn't work out how. It needs something extra on top to give you a reason to work through the puzzles I think.

I've been thinking on these lines recently too, and maybe the game could be to allow others to experience the fun you're having in building these rules and watching the outcomes? Letting them author the rules, and watch the outcomes. Or letting them manage and upgrade the bots, sorta like an overlord who doesn't actually chop wood etc.

This is kind of a nebulous idea (and definitely not new), but spawns from the fun I've been having the past few weeks in writing a bunch of simple rules for cities to attack, ally, trade with each other. Watching kingdoms evolve, alliances form and break, funny situations like a rock shortage eventually triggering a massive war among all kingdoms, was fun. It might not be as fun for a passive observer, but as the author of the rules, the feedback loop of making changes and watching the emergent outcomes was pretty neat (kinda like programming, heh). But it is a scary path to go down, if the intention is to market it as a game, because it doesn't look or sound like any "real" game.

On a different note, Dwarf Fortress is ripe with such emergent outcomes. On another different note, Robocode is quite fun where you author bots and rules and watch how the bots fare against each other.

Is this the story? http://www.young-adult-books.com/read/buy-jupiter-and-other-... (link says "buy", but looks like the entire story is on that page)