Mason Remaley

@masonremaley.bsky.social

151 Followers 175 Following

Independent game developer, board member on the Zig Software Foundation. Shipped Way of Rhea, working on something new. 🏳️‍🌈 The good stuff goes to my mailing list, follow me there instead: gamesbymason.com/newsletter/

Screenshot of part of the post

Simulated splatter paint

Animated colored bars

Gold like rippling surface

Various voronoi noise patterns

Simulated pool caustics

animated noise, vaguely reminiscent of water

A screenshot of the links in the linked blog post

Nathan Fielder holding a very thin slice of watermelon

Promo art for the Staying Inside 2025 conference, features a bridge (presumably in San Francisco.)

A screenshot of the Tracy profiler

past blog posts: Fullscreen Exclusive Is A Lie (...sort of), Notes from the Q&A Sessions with Steam, Highlights from 'I spent 6 years developing a game in Rust and it just shipped, AMA', Making Your Game Go Fast By Asking Windows Nicely, It's Not Survivorship Bias (Talk), It's Not About The Technology - Game Engines are Art Tools

|y - 1| < |x - 1|
|y - 1| < |x - 1|

y = |x * (-0.5x^2 + 1.5)|

/// Fast approximate inverse square root using a dedicated hardware
/// instruction when available.
pub fn invSqrt(f: anytype) @TypeOf(f) {
// If we're positive infinity, just return infinity
if (std.math.isPositiveInf(f)) return f;

// If we're NaN or negative infinity, return NaN
if (std.math.isNan(f) or
std.math.isNegativeInf(f) or
f == 0.0)
{
return std.math.nan(f32);
}

// Now that we've ruled out values that would cause issues in
// optimized float mode, enable it and calculate the inverse square
// root. This generates a hardware instruction approximating the
// inverse square root on platforms that have one, and is therefore
// significantly faster.
{
@setFloatMode(.optimized);
return 1.0 / @sqrt(f);
}
}

/// Very fast approximate inverse square root that only produces usable
/// results when `f` is near 1.
pub fn invSqrtNearOne(f: anytype) @TypeOf(f) {
return @mulAdd(@TypeOf(f), f, -0.5, 1.5);
}

The same graph, but zoomed in near (1, 1) where the linear approximation works well

A 1/sqrt(x) curve with a linear approximation that at first glance doesn't appear to fit it well

NOTE : The t/=d bit in the preceding code is an optimization technique. This compound operator lets you divide
and reassign t, and use its value in further operations, all in one step. The Flash Player uses a stack-based virtual machine that has four “registers” or memory locations reserved for holding data temporarily. Information can be stored and retrieved much faster from a register than from a variable, but registers are rarely used in Flash-generated bytecode. However, in-line syntax like p = (t/=d) * t is compiled to bytecodes that use one of the registers to temporarily store a value during the calculation, speeding up the process. (A special thanks goes to Tatsuo Kato for first applying this technique to my code.)

v = 7.5625 * (v -= 1.5 / 2.75) * v + 0.75;

An asteroid bouncing back and forth as if it was on a spring