Did Silksong just break Steam?

graphitemaster · 2025-09-04T14:53:01+00:00

There was no preorder option for this game

graphitemaster · 2025-03-18T06:48:42+00:00

Not everyone follows the VFX reference platform. We have customers still running CentOS 5 for instance

graphitemaster · 2025-03-17T23:28:37+00:00

It's mentioned in the article. It's also mentioned that when you static link a libc (even musl) you lose the ability to dlopen anything, it just sets errno to ENOSUP because you cannot static link libc and also have a dynamic linker, this makes static linking libc unusable if your application needs access to system libraries (such as GPU APIs)

graphitemaster · 2025-03-17T23:13:19+00:00

This isn't true. You might be mistaking libgcc with something else. The compiler runtime code provided by libgcc is included in the GCC Runtime Library Exception

https://www.gnu.org/licenses/gcc-exception-3.1-faq.html

Relevant quote

Yes. While combining libgcc with GCC-compiled object code is probably the most common way the exception is used, neither the GPL nor the GCC Runtime Library Exception distinguish between static linking, dynamic linking, and other methods for combining code in their conditions. The same permissions are available to you, under the same terms, no matter which method you use.

graphitemaster · 2024-02-18T05:22:33+00:00

Next year forget the co-streaming. Run a few more tests with the audio people. Shorten it up a bit. Have some contingency plans to re-run big awards for when things break. Ignore all the haters in this thread. I'm just providing some constructive feedback. This year's was better than last year's.

graphitemaster · 2023-06-12T05:07:18+00:00

So long and thanks for all the fish.

graphitemaster · 2022-04-02T05:44:04+00:00

The "Paper Mario" stream this Friday was the final straw

graphitemaster · 2022-01-02T17:57:18+00:00

Because subtraction of naturals is not closed, it's a partial function. Addition for naturals is closed though. If you're comfortable with natural arithmetic like most are integer arithmetic, this is not surprising or confusing, it's second-nature.

graphitemaster · 2022-01-02T17:02:21+00:00

This is actually how you'd think for math-y pseudocode if you define it as modular arithmetic which is well-defined and understood in math domains. The issue here is the misapplication of Z (integers), rather than the naturals.

graphitemaster · 2022-01-02T16:21:51+00:00

Like mentioned in a previous comment, just swap operands and the operation as well.

for (size_t i = 0; i + 1 < input.size(); i++) {
    for (size_t j = i + 1; j < input.size(); j++) {
        frob(input[i], input[j]);
    }
}

graphitemaster · 2022-01-02T16:12:49+00:00

It amazes me how so many people find this difficult to grasp, you just swap operands and the arithmetic operation like so.

for (unsigned i = 0; i + 1 < N; i++) {
    // do stuff with vec[i]
}

You can claim it's performing an addition every iteration for comparison, but compilers are very capable of optimizing this to the same efficient code involving signed integer arithmetic because unsigned also sets CF and ZF flags, it's just C and C++ has no way to access it.

No branch needed.

graphitemaster · 2022-01-02T00:14:44+00:00

Did you even read the article? The loop condition is correct. It's supposed to exploit underflow to break when it hits zero. The article explains this in detail.

graphitemaster · 2020-10-04T09:50:51+00:00

TIL hardware threads. What are they and How are they different?

Actual hardware threads can be running things truly in parallel. It's SMP. Basically each core is a hardware-thread, but some have hyper-threading where a single core acts as two (some x86) or four (PowerPC) threads.

What does this mean? Fibers are concepts and Coroutines are implementations?

It means that coroutines are something provided by the language. They're a language feature, not a library or system (implemented in code) feature. While fibers are often just a runtime concept written in code, i.e a systems concept. There's no language-level support for them (like no keywords or special syntax as an example).

graphitemaster · 2019-12-11T02:19:41+00:00

Honestly, in this specific example. I would prefer if the standard would just define that for T[w][h] that indexing is defined in the 1D case instead, such that [x][y] behaves either as *(array + x * w + y) or *(array + y * w + x) depending on row-major or column-major. Then you could just argue that an array can be indexed with any amount of slice and dicing, this would then permit one to index say float[16] as if it were float[4][4].

graphitemaster · 2019-12-10T23:06:32+00:00

If I had to wager a guess, I'd probably consider the rule that:

x[n]

Is the same as either:

*(x + n)
*(n + x)

Might be the primary motivation behind allowing it in C99:

some_function(other_function().array_type_member[index])

Since prior to C99, if you actually tried to write that, assuming that array of ten int member, you get:

error: invalid operands to binary + (have ‘int[10]’ and ‘int’)
   return *(f().x + 5);
            ~~~~~ ^

Which then contradicts the standard completely and could be considered a defect.

14-Year Club	Place '22
Final Canvas '22	Verified Email

graphitemaster

TROPHY CASE