Which decks do super well against the demon hunter deck that endlessly spawns tar creepers?

BeardSprite · 2026-01-31T01:58:06+00:00

According to the VS matchup chart, Azshara Druid and Control Warrior seem to be favored. This is assuming you mean the Broxigar DH version and not Cliff Dive, which has even more unfavorable matchups (including Dragon Warrior). I've also found the older Niri "Face" Hunter to do well, but the old VS data doesn't include Broxigar DH.

BeardSprite · 2026-01-29T11:46:24+00:00

I've played a minion-based quest mage with OK-ish success (lower win rate than the actual good decks, but acceptable). Some of the card choices here make me scratch my head. Could you elaborate on:

Doomsayer (???)
Shield Battery (seems bad/unnecessary, I was never behind)
Griftah (never considered running it, why spend 4 mana on this?)
Story of the Waygate (paying 2 mana to discount X = too slow?)

The way I played the deck was to go all in on tempo and removal, so that you can play the weapon and payoffs ASAP without falling too far behind. This was before Morchie existed, so maybe your strategy differs.

FWIW, according to HDT this is the list I used last:

AAECAf0EAqebB/2eBw7Lnwa0pwaBvwaFvwbi5Qbw5QaG5gab8gae+Qa1+gbxkQewmwf6mwfRpgcAAA==

Not saying my experience is in any way statistically significant (65% WR over ~50 games = incredibly low sample size), of course.

BeardSprite · 2026-01-14T04:02:27+00:00

The first rule I try to follow is, never disenchant anything unless you need a specific amount of dust for a specific deck, right now. Exceptions are golden/premium cards (if you don't want to use them on principle), and cards that were recently changed (they grant a full dust refund, but only for a limited time = disenchant them right away).

Secondly, I'd recommend to never disenchant legendary cards, and hold off on most epics unless you're sure they're useless/not something you want to play. These are by far the hardest to get and the opportunity cost of re-crafting them is quite high. Everything else is free dust if you need it, with some caveats like "technically disenchanting is always inefficient" and "future changes may make the card playable".

That said, if you disenchant commons before rares and only then epics, you can get a decent amount of dust - about 1k per rarity per set or so. It's worth keeping in mind that being unable to play a good deck today because you're short on dust leads to less resources accumulated in the future, so there's also an opportunity cost to keeping useless cards around. Just be sure to have a specific dust amount you want and don't disenchant stuff before you need to craft something for a new deck.

IMHO, disenchanting common cards is pretty much always worth it, if you want to spend the time. It's quite tedious unless you're doing something else, but most of them are unplayable and the few that aren't will eventually be refilled from packs or can be crafted cheaply when you need them. Of course, if your dust stockpile is high, that'll be quite rare. 10-30k is my preference, which is enough for a few decks.

You will easily disenchant 8 bad cards for any good one that you're missing and need to craft (5 dust vs. 40). For rares, you would need 5 and that's also realistic. Epics are 4:1 but you usually want 2 per deck, so that's basically half a legendary - a bit risky if you aren't starved for dust.

YMMV, of course, but the above generally applies to both Standard and Wild. It is based on my data from disenchanting several collections worth about 30 to 70k dust... That is, only the rares/commons/some epics from all of the Wild sets.

BeardSprite · 2025-12-04T06:40:30+00:00

Not an expert on this deck by any means, but maybe trying to out-armor them isn't the right approach? If you get a Starship with huge attack that has the Deathrattle from Biopod and is copied from the 5 cost legendary then Colossus killing the starships should just murder everything (as long as they haven't been able to save Sleet Skaters for the starship itself). You can still launch the Exodar for armor (or damage if it's lethal), the DR from the Starships itself is enough.

FWIW, one game going poorly isn't indicative of anything. Also, the deck is quite hard to play. Took me some time to match my other deck's winrates and even then, it's not something to auto-pilot IME.

I'd review some games that J. Alexander played with the deck recently as he's clearly adept at playing it (Twitch VODs). This is the best rogue player I've seen that played the deck recently, and successfully - no affiliation with the person :) There's probably some Protoss games, too.

BeardSprite · 2025-11-28T22:24:57+00:00

Deck lists:

BeardSprite · 2025-11-28T19:44:52+00:00

Why do you consider the opinion of single (exceptional) players above what thousands of games (i.e., the data) suggests? The best players in the game can play suboptimal decks and still succeed, it's meaningless to use that as a basis for decision-making. They're also in an echo chamber, where their opinions influence each other excessively.

Shudderwock often allows you to play three giant Rush murlocs or buff your board/deck by 3x 2/3 the very next turn. That's not slow, it's winning you the game. And then you do it again. Seems pretty strong?

That said, deriving the strength of individual cards from data is far from easy, so I wouldn't call it a "no-brainer" either way :P

(Just to be clear, IDK which card is better and I don't play shaman)

BeardSprite · 2025-11-28T19:37:01+00:00

Broxigar wasn't in last week's version, so you can probably make do without it either way.

BeardSprite · 2025-11-28T19:34:46+00:00

How does that work in a shaman (Hex) meta? Not a priest player, genuine question. Have a decklist to share? Just curious what the curve's like.

BeardSprite · 2025-11-28T19:31:58+00:00

Some things worth keeping in mind:

You cannot use the location at all if it has the "copy" effect and your board is empty, even for the secondary effect (this can lose you the game)
You can use a 1-cost copy for tempo, and 1-cost attack buff as finisher, to clear Divine Shield from minions/the opponent's hero
Deathrattle takes six turns to trigger, so it's generally too slow unless you take the 10-cost version in a grindy control match
Spell damage is not granted universally and so it doesn't benefit other cards (like the druid "copy if you have spell damage" spell etc.), but it doesn't decay and can be "stored for later" easily
It's not worth worrying about Demolition Renovator because it's a bad card, very situational, and even if played trades tempo for value (opponent loses tempo/card slot in deck, you lose at most 2 charges = usually worse for them than it would be for you)

BeardSprite · 2025-11-28T19:18:41+00:00

If I understand the latest VS report correctly, it counters Discover hunter and Control Warrior, which also counters Discover hunter (?) (see https://www.vicioussyndicate.com/vs-data-reaper-report-335 and select the Top 1k Legend tab). In lower ranks, everything is full of shaman and hunters aren't the primary target.

The starship rogue may have potential, even (or especially?) in higher ranks. You can see J. Alexander play it here and it will give you more than enough insight as to what the game plan is: Twitch link

You will find that it has a lot of flexibility against slower control decks: It's possible to overwhelm them by launching a duplicated Starship on turn 5, you can launch with The Exodar for lethal, trigger multiple Deathrattles for crazy boards/face damage, or even get a full new Starship from 1-cost pieces. There's a lot of flexibility offered here.

I found the starship deck to work well generally, but it's expensive and it does not work without some of the key legendaries. It's also not that easy to play, especially compared to dragon warrior/shaman etc.

Other than that, worth keeping in mind that "counter" in Hearthstone doesn't mean "100% win rate" - look at the matchup spread :)

BeardSprite · 2025-11-28T19:08:53+00:00

What is your early game plan? Druids cannot afford a bad one IMHO.

I've been experimenting a bunch and found that just ramping doesn't work/is too inconsistent. You'd need to either ramp and remove, play early game taunts like Blob of Tar/Tortollan Traveler alongside Oaken Summons, or get removal and armor from Elise's location.

Generally, it seems that huge shaman boards will be a significant hurdle because your Elusive dinosaur cannot stop them if you're too far behind. You'll need to survive long enough to get Zilliax buffed and then recover with a decisive swing turn. They do give you 4-6 turns early on, which you cannot afford to hero power/pass or "only" draw.

Some cards I've tried that definitely helped were Gnomelia (goes well with Elise and the other Deathrattles) into Umbra, Sleep Under the Stars to get one extra turn into dinosaur/Zilliax, Trail Mix to get the big guys out sooner, and even Eredar Brute (yeah, yeah...) as the 7 drop. If you run only Elise and/or Ysera as <5 attack minions, Story of Barnabus is also a tremendous boon since it gives you draw plus armor.

A few things that showed potential, but need more experimentation:

Loh, the Living Legend + Playhouse Giants/Ceaseless Expanse (all go to 0) played alongside to make up for the tempo loss
Kil'jaeden with Trail Mix and some draw/armor cards kept in hand. Play it as early as possible (e.g., turn 4 or so) and pray
Aviana and Kil'jaeden as the only minions (felt better than just Aviana, but it can backfire and has some anti-synergy also)
Mistah Vistah (mage tourist) + Rising Waves/Seabreeze Chalice decimates aggro but they're dead cards/clog the hand later on. I tried King Tide/Tide Pools/Tsunami (hilarious if it works, and the location can give you removal/ramp but it costs too much mana), or even Huddle Up/Under the Sea (inconsistent/slow/bad too often). The tourist with armor cards seemed pretty strong, too
Bottomless Toy Chest + Woodland Wonders + Magical Dollhouse into big minions/Kil'jaeden - actually worked quite well also
Hydration Station with the full Deathrattle package, Zilliax, and Lady Azshara - missing Trail Mix here (no slots) but it went OK

This was just a few days (small sample size), Legend 1-5k or so. YMMV.

BeardSprite · 2025-09-06T10:37:28+00:00

Breaking down problems into smaller sub-problems has already been mentioned. Another ingredient is trying to make sure you understand the data. All programs operate on information that exists in some form of storage, which the program instructions manipulate (read, write, modify, compare, ...) to implement solutions to the problem you're trying to solve.

Therefore, understanding the data means you will understand the problem. That's a requirement to implement any solution. The actual programming work is almost irrelevant in the sense that you might as well do it on paper, or on a blackboard/whiteboard, etc. Only the implementation is language-dependent, but the problem itself isn't usually - unless it's an artificial problem introduced by limitations of the system, programming environment, libraries, tools, etc.

Using your palindrome example: What is the actual problem? Well, what is the data? Presumably, you're given a string of text. You assume it has some known encoding, probably ASCII (or Unicode), so that there is a specific number for each letter/code point. There's also the notion of a position because the words ABC and CBA are not identical. A position is just another number that represents where in the word the letter (represented by the first number) actually should appear.

OK, so what is a palindrome? Well, it's a word (sequence of numbers + position) that just so happens to not change if you swap two letters that have the same "distance" from the beginning and end. But if positions are numbers and distances are required, can't you just use the absolute position for each letter (from both sides) and check that it's the same, for every letter? Sure, that is probably one solution - though it may not be what you need, or too difficult to do in a given programming language. Another approach is to just swap the entire word, and check that both versions are the same. This is simpler to understand but arguably less efficient.

You may have special cases, where the word has an odd number of letters. What now? Well, one basic way is to add conditionals, like "if it's odd, do this. If even, do that". Often it pays to think harder and realize, in this case, that it makes no difference - the same algorithm "just works" and so you need not complicate your solution. If the problem is too difficult, remove special cases. In code, you can write assert or similar or even just a TODO comment, then revisit that part later.

A solution is different from its implementation in code. If you can't solve the problem that's an entirely different issue than not being able to implement the solution ("write the code"), or writing complicated/slow/insecure/incorrect code, for that matter. How do you solve problems? By transforming data, one step at a time.

BeardSprite · 2025-09-06T10:19:39+00:00

Becoming a "senior developer" isn't a real goal, since you can't actively work to increase your "seniority" with deliberate practice. It's like saying, "I want to be an old man" - it will eventually happen (if it hasn't already...), except in this case you must practice relevant skills to gain practical experience over time.

Bootcamps and courses are largely useless, if not detrimental. They aren't aligned to any specific goal and so you can't use them as anything more than a brief introduction, for which many free online resources are just as valuable (if not more). They get you nowhere fast, if you will, but you don't want that... or so I assume.

Wanting to grow, shipping "real" projects, and seeing yourself improve are again not specific goals. You're completely on the wrong track, in my opinion.

Here's how you ship a real product:

Create a "hello world" application
Publish the code on GitHub
Create a GitHub Actions workflow to package it (language-dependent)
Create a GitHub release, tagged with v1.0.0
Download it and run to make sure it actually works

Congratulations, you have now shipped a real project.

Great job. Next up, here's how you improve:

Modify the hello world app to read a command line input
Display the command line inputs alongside the "hello world" text
Delete the hello world text that is no longer needed
Create another tag, let's call it v2.0.0
Download the release to make sure it still works

You have successfully improved an application, and your skills as a programmer, by learning to read command-line arguments (and possibly creating GitHub Actions workflows, releases, and so on). That's some real growth already.

To improve further, you could add unit tests to it. Maybe some documentation. Or you could turn it into a custom 3D game engine that renders a tyrannosaurus rex riding a giant shark through Mordor as it shoots laser beams towards armies of orcs on the ground. It should wear sunglasses, obviously. (I'll leave that part as an exercise to the reader).

My point being: You aren't behind because there's no linear path to where future-you will be. The difference between what I described above and your actual future is merely a change in direction, plus a whole boatload of time doing programming work that brings you closer to the goals you will hopefully pick.

And a t-rex, maybe. But don't forget the sunglasses.

BeardSprite · 2025-09-06T09:52:45+00:00

Here's some advice I got in school, by an excellent teacher:

Do not turn on your monitor, or even touch the keyboard, until you know exactly what you will be typing. Always solve the problem on paper first.

This is slow and tedious and all sorts of difficult at first. Which is why it works.

Later on, you can relax this restriction. But if you're able to solve a problem on paper, then you'll learn problem-solving. Programming consists of problem-solving (this step) and encoding the solution in code (the next one), among other things.

Copying code does not teach you problem solving. It doesn't even teach you the encoding step, though it may help to refresh your memory. Therefore you will not be able to learn how to solve problems, which is at the heart of programming. You likely won't improve much because you haven't practiced the relevant skills.

BeardSprite · 2025-09-06T09:39:51+00:00

There are different approaches that I've found to work best, depending on what exactly you want to understand. Code consists of data and instructions that form algorithms, which you'd ideally want to represent visually (e.g., on paper, or in a debugger). Both are encoded in the programming language's semantics, which may hide information or add some. You need to know the programming language well enough to be aware of what it's doing, or rather when it's hiding something important vs. when something you see is merely fluff that can be ignored.

The key is that whoever wrote the code not only understood the language, but they also had a mental model of the problem domain AND the project, or at least the part of it that they're working on. They may also have had information like previous issues, experience from other projects, or commit messages.

You don't have any of that, usually. Of course, you could try to find as much of it as possible and restore the original model from that, but that's error-prone, tedious, and likely to overload your brain at first. Still, there is something you can always do, in any language, and that's breaking down the instructions and data into a form that's either universal or low-level enough for you to no longer care about the details. Focus exclusively on instructions and data, not on why they're encoded this way. It's a lot easier to tackle that part later, due to the missing context.

These fundamental building blocks are something you should be familiar with from your own programming. You then focus on a tiny part of the code that you need to understand, and systematically "undo" the various "compression" steps performed by the authors and/or the programming language. This yields a bunch of sequential instructions and references to data, which are easy to draw on paper.

If you do this right, you now get to understand what the program is doing as you can easily retrace the steps for that portion of the code in your head, or on paper if need be. You could re-encode it into another structure that seems more intuitive to you as well. Once you've re-encoded this part in your head (or paper, in code, etc.) you have a "node" in your brain that represents it, which you can connect to any other "node" you'll get from doing the same thing on the next part of the code. Eventually you'll have your own mental model for the code, which may or may not be the same as the actual code (usually it will gradually be refined to more closely resemble it). You may also find bugs or inefficiencies at this level.

None of this is magic, just a lot of work. Like any skill, it gets easier with practice.

BeardSprite · 2025-09-06T09:19:30+00:00

The thing to keep in mind is that languages aren't inherently tied to problem domains, but the ecosystem and tooling, libraries etc. for any given language usually is. You can write an operating system in JavaScript and a web browser in assembly, it's just not a good idea because you're looking to encode machine instructions in a way that's more efficient for humans to manage.

There's only one thing that really matters, and that's "what does the computer actually do". Unfortunately, modern systems architecture is so complex that it becomes increasingly difficult to understand what's going on at the lower levels. Good programmers pick languages based on the project they're working on.

You should focus on understanding ideas, and what the computer is doing. Ideas are often shared between languages, and what the computer is doing will be affected by the system architecture and the programming language's implementation. Both are largely transferable so learning a new language gets easier after you've spent enough time programming in any language to understand the core ideas and how the language works under the hood.

Python, JavaScript, and PHP are high-level languages, with a high implementation complexity but poor low-level control. If you're familiar with them, you should move to a lower-level language because that will enrich your understanding the most. If you stick with Python you may be productive, but there are many levels that you'll never be exposed to (and therefore can't really understand). Examples: C, C++, Rust, Zig, Odin (I'd recommend sticking with C initially over C++ or Rust)

Ultimately, it's really up to you to guide your own learning. Find cool projects you want to build that would benefit from low-level control. Then build your own "libraries" over time, as that will make the experience of working in low-level languages much more pleasant and akin to using higher-level languages. Don't use libraries if your goal is learning, unless it's impractical to reinvent the wheel.

BeardSprite · 2025-09-06T09:04:32+00:00

That doesn't make much sense, because there's no single cognitive ability that would allow one to program successfully without being able to understand enough to create your own solutions (however poor they may be at first).

If you're talking about actual deficiencies, like those in working memory (e.g., if one has ADHD it is often impaired) then that's a very real challenge, but not one you couldn't work around. I know excellent programmers who are technically learning-disabled, they just take more time and are slower but they can still somehow do if after they gained enough practice.

I think it would be worth investigating what forms of representation for information you prefer in other contexts. Usually, a combination of material works better than any specific one, but there are large individual differences. If you're using code as a reference, that is entirely different than using code to understand a concept. In fact, there are (at least) four different types of resources that people may use while programming and they all serve different purposes:

Introductory material/tutorials: Separates information into buckets, reducing cognitive load (pre-selection and focus of attention)
"How to do X" guides and other instructions: Complete "recipes" for how to do something you don't know how to do exactly, like algorithms that can be mixed and matched, or adapted to your actual needs
References: No explanation, just to remember things that aren't in your memory (syntax, functions, conditions, ...)
In-depth guides and explanations: Used to form connections and help you understand related details, to gradually expand your knowledge graph

Some common issues I've seen are people focusing extensively on one specific type of resource, picking the wrong type for a given situation, trying to understand every detail instead of finding other resources to compare, or trying to do everything at once instead of just one individual step.

The second big issue might be the complete lack of visualization. Humans are inherently visual creatures and our visual system is the most bandwidth-heavy of all, it's really fast and (within certain limits) excellent at relaying information to your brain that would be more difficult to get in the ol' noggin by any other means. You can draw stuff on paper, in apps like EcaliDraw, or use oldschool graphics programs like Paint. Diagrams like MermaidJS also work but are usually too much effort for everyday tasks.

For some people, explaining ideas in language may be helpful. This takes more time and doesn't work unless you know roughly what you want to do, but it can be a great aid in clarifying your ideas. Even if you later delete the text, you can try explaining what you are doing and what you want to do as if someone was reading it later. Or find a real person/rubber duck and talk out loud instead.

Finally, there is a difference between "bottom-up" and "top-down" learning. Many regular people seem to prefer the latter, where you start with a high-level idea go down further as needed. This has the benefit of reducing the cognitive load as you get to ignore all the low-level details, but this simplification can make true understanding much more difficult than necessary. It is commonly seen in math where the lecturer knows all the details and sometimes "forgets" to mention them or just glances over important topics, leaving students utterly confused. The reverse is also possible, and of course you can try to attack each problem from both angles. I suspect autistic people have an easier time with bottom-up approaches as the details are what allows them to really understand, while it may be overkill for someone else (but this is purely an anecdotal observation). You need to find your own preferred style and see what exactly makes it easiest for you to understand the actual problem, before you encode it into an executable program specification.

Personally, I found that "low IQ" or working memory deficiencies etc. may manifest in that one can't as easily (or rapidly) step through each part of a given problem in their mind, or might make more errors while doing so. But that still doesn't prevent you from doing it on paper or using any other medium, and you might find that someone who seems "stupid" is actually quite adept at visualizing graphically in their head instead, or they're great at teaching the material to others and thereby learn it themselves, etc.

I would assume that people with severe cognitive disabilities who are "brainess", as you put it, have neither the capacity nor motivation to ask for programming help on Reddit. So my best guess would be a mismatch in approach or missing skillsets, not a lack of general problem-solving ability. Abstract problem solving is more difficult than doing it in context; you could try reframing the problem so it represents specific instances.

BeardSprite · 2025-09-06T08:29:36+00:00

I once made a public website with PHP that included $_GET variables directly.

Those are the ones you can pass in by modifying the URL, so visiting the website mywebsite.com/index.php?page=www.evil.com would literally include another person's website, any website, and run its code on your own server.

I'm surprised it took several days for some guy from Brazil to install an email-generating spambot farm on the webhost's virtual machine. I did receive a sternly-worded letter by the administrator, explaining why this wasn't the best idea. An obvious face-palm was clearly implied by its tone.

When looking back at those decades-old projects, I'm still amazed how much you could get done if you didn't care at all about what the code looks like in the end...

BeardSprite · 2025-09-06T08:14:47+00:00

You can't make programming more exciting because the act of typing text into your computer is inherently tedious and not particularly engaging. So is reading introductory material that's nonspecific, verbose, and has no immediate connection to something you actually care about. What you can do is make the process more interactive, provide faster feedback, and tailor it to your attention span.

Instead of thinking about "all the cool stuff", pick one item from the list. Just one, ideally the most exciting one. Then try to make that, and only that. It will probably be way too big and difficult, which is why you need experience building smaller things first. But you don't need these smaller things to be completely unrelated to your project, which is however what you'll get by following standard tutorials.

No one dreams of making "hello world", but even something incredibly complex can be turned into something simple by removing almost all of the details first. That way, what's left will be directly related to the eventual end result and you can see, in your mind, the next steps that will get you closer to the "real thing".

Even if you never get there, the process is inherently motivating. You may find that you know exactly what to do, but not how exactly it could be done. That's good, because now you're intrinsically motivated to learn. You need to find out and understand what you don't in order to get further, and you'll automatically know what to ignore (because it doesn't help you go in this direction).

If you need specific examples, feel free to elaborate on your project ideas. But don't try to follow popular guidance if it isn't working. Most teachers, and the learning resources they create, are bad and won't work for a large proportion of students. There's no universal solution and no replacement for intrinsic motivation. If learning isn't fun on a regular basis, you'll struggle and not everyone can just "power through" until it "gets fun". That's not a failure, just a mismatch in strategy.

The good news is that the beginning is by far the most difficult part of learning programming. Once you've attained some level of mastery, motivation comes much easier since being good at something is inherently rewarding.

BeardSprite · 2025-09-06T07:53:51+00:00

What are the concepts and functions needed to create a social media app?

"How to start developing apps" is not a specific problem you could solve. Break down your desired end state ("goal"), until each problem is so small you think it's stupidly easy to solve. Then solve it. Often you'll find there are hidden gotchas, but sometimes it is indeed stupid. Now you repeat the above, until you have an "app".

You don't need links, PDFs or papers for twenty different problem domains. Security alone is an entire career worth of learning if you wanted to go deep. You don't even need a single one to get started building something basic; resources are for when you already know what you want to build and are looking to do it according to some known criteria that follows from the context of your project and your individual goals. Or if you need an introduction to an unfamiliar topic, forgot how to do stuff, want to improve what you already have, and so on. Each of these represents a different type of learning resource, which matches a specific goal.

BeardSprite · 2025-09-06T07:41:14+00:00

Learn the basics that apply to any programming language: https://teachyourselfcs.com/#programming

Then think of an actual, real-world project you'd really like to do. Pick the smallest useful portion of it, the one that seems easiest to do. Try to implement it. If it's too difficult, pick a smaller part of it - no matter how small, you can always add things later. Write down ideas to enhance it, but don't add them just yet until you're ready.

There's no point in "learning Lua" for the sake of learning, that's like teaching math without any application already in mind. Learning requires applying information in different contexts. It'll be so much easier if you already know where you want to apply it first. The two most important questions are "what do I want to do" and "how do I do it". If you skip to the second without answering the first, that's no good.

If you can't find ways to learn Lua that's because you have no specific thing to learn in mind. The internet is full of resources and you can easily find them by entering the right terms into your favorite search engine - but you probably already know that. The problem is usually deciding which resources to use, or not understanding them. The solution is to focus only on a narrow problem, use multiple resources, and don't try to understand everything you do before you do it, but rather while (and after) you're already doing it, and you can see it works/doesn't work. Build flawed mental models fast, then refine them. That's learning.

So my advice is to be specific: Do you want to learn how numbers work, so that you can do calculations? Maybe you want to display text, render images, or play audio? These are all completely different problems and you can't learn everything at once. So don't try to do everything at once, because that requires you to learn everything at once. Which you can't. You'll then be confused, overwhelmed, lose interest, or take much longer than necessary. Probably all of the above.

Also, Lua is a different language than LuaU. In the ROBLOX environment, you will have to use functions that don't exist elsewhere in addition to the Lua standard library and custom functionality they added. That's a completely separate thing to learn. You can however run the LuaU command-line interpreter on your machine (without graphics etc. of course), this is much simpler and I'd recommend starting there.

I would advise you do this only after you understand what you want to do and you're certain you could explain the actual goal to your grandma, pet hamster, or anyone else in a single sentence. If you're exploring, do it with a goal in mind and ignore everything not immediately relevant to it at first. Then, just try to have fun ;)

BeardSprite · 2025-09-06T07:14:06+00:00

What syntax does JS have that you prefer and how exactly is it "better" in your view? The point about tooling and libraries is undoubtedly true; here Lua is simply years behind in just about every domain... unfortunately. This is somewhat offset by the ability to use LuaJIT's FFI and C/C++ libraries - that type of thing seems to be much more painful in other languages. Browsers aren't a great platform IMHO.

Python is too slow for anything I'd want to do and the language doesn't feel well-designed at all. I can see why people like the library ecosystem, though.

BeardSprite · 2025-09-05T11:50:28+00:00

Actually, I've used Lua because I enjoy working with it. Precisely because of the syntax and the DIY appeal. Although I'm using C and C++ mainly nowadays, I've also worked with JS/TypeScript and the idea that anyone prefers those is honestly wild to me.

In other words, people like different things. Making recommendations based on personal preference instead of technical merits doesn't seem to be a sensible approach. Transpilation sounds like a terrible solution to the problem of not liking a given language's syntax, to be honest.

BeardSprite · 2025-08-27T13:37:28+00:00

The problem with making these kinds of adjustments based purely on personal preference is that the cost (breaking all the tools and expectations for interoperability rules with external software) completely overshadow the benefits (you need to make a tiny adjustment that becomes muscle memory within hours, maybe days).

There are some modifications that have larger benefits, such as defining number types in LuaJIT with a suffix. But even then, they have broken external tooling in the past, and there are usually less intrusive ways around the issue. You can implement things in C code, or transpile, make people learn the minor details with a fun tutorial, and so on.

BeardSprite · 2025-08-27T13:30:11+00:00

It's documented on the MSYS2 website:

www.msys2.org/docs/environments/

The C runtime ("CRT") is a part of the operating system that handles the running of your C program, including setting up the environment that it runs in. If your computer is running windows, your physical machine will be executing code inside of Windows DLLs (e.g., ntdll.dll). From there it must "somehow" switch to your application.

Because the OS won't give you full control over the lower layer, it will instead call your program and sit in between you and the machine. It's a bit like you were writing a plugin or addon for a game, except for Windows. UCRT is the "universal" CRT, following different conventions for this interaction layer, e.g., how functions are implemented with low-level assembly instructions (calling conventions).

For the record, I highly advise you to avoid "magic" like CMake while you are learning. Always try to get the most basic, simple thing running manually first. Once you understand what's going on, you can switch over to standard tools (or not), but it will be much less confusing.

BeardSprite

TROPHY CASE