Atrix256

•	https://minionsart.github.io/tutorials/
•	https://www.alanzucconi.com/tutorials/
•	https://www.youtube.com/@DanMoranGameDev
•	https://catlikecoding.com/unity/tutorials/
•	How to get the spider verse look in blender: https://garagefarm.net/blog/recreating-the-spider-verse-look-in-the-blender-node-editor
•	GuiltyGearXrd’s art style: The X Factor Between 2D and 3D (GDC) https://www.youtube.com/watch?v=yhGjCzxJV3E
•	Genshin Impact: Crafting an Anime-Style open world (GDC) https://www.youtube.com/watch?v=-JFyAdI_rO8
•	https://ameye.dev/
•	Toon shader using unity: https://roystan.net/articles/toon-shader/
•	Mange stylized rendering in VR (SIGGRAPH) https://dl.acm.org/doi/10.1145/3277644.3277768

o11c

Note: this was originally several Reddit posts, chained and linked. But now that Reddit is dying I've finally moved them out. Sorry about the mess.

---

URL: https://www.reddit.com/r/ProgrammingLanguages/comments/up206c/stack_machines_for_compilers/i8ikupw/ Summary: stack-based vs register-based in general.

There are a wide variety of machines that can be described as "stack-based" or "register-based", but not all of them are practical. And there are a lot of other decisions that affect that practicality (do variables have names or only address/indexes? fixed-width or variable-width instructions? are you interpreting the bytecode (and if so, are you using machine stack frames?) or turning it into machine code? how many registers are there, and how many are special? how do you represent multiple types of variable? how many scopes are there(various kinds of global, local, member, ...)? how much effort/complexity can you afford to put into your machine? etc.)

• a pure stack VM can only access the top elemen

paniq

Hash Integrals: Slice Hashing below O(log n)

Update: the technique employed here is called a polynomial rolling hash as I have recently learned.

Some notes on how to enable fast computation of hashes of slices of vectors (below complexity O(log n)), as well as hashes of joined vectors.

We start from first principles. To simplify matters, a vector has the same element type as our hash, which stands in for the actual data element we wish to hash.

Each vector v is paired with a secondary summed-hash vector h of which each element i stores hash(v[0..i]) to form a tuple of vectors (v,h). Appending a new element p to v is then performed in O(1) as follows, with a simple auxiliary linear operation:

jiacai2050

const std = @import("std");
const fs = std.fs;
const log = std.log;
const os = std.os;

fn walk(dir: fs.Dir) anyerror!void {
    var it = dir.iterate();
    loop: {
        while (it.next()) |entry| {
            if (entry) |e| {

lithdew

const std = @import("std");

const sparse = @This();

/// This is an implementation of a paged sparse set that stores the payload in
/// the sparse array.
//
/// A sparse set has a dense and a sparse array. The sparse array is directly
/// indexed by a 64 bit identifier. The sparse element is linked with a dense
/// element, which allows for liveliness checking. The liveliness check itself

mitchellh

//! Implements a texture atlas (https://en.wikipedia.org/wiki/Texture_atlas).
//!
//! The implementation is based on "A Thousand Ways to Pack the Bin - A
//! Practical Approach to Two-Dimensional Rectangle Bin Packing" by Jukka
//! Jylänki. This specific implementation is based heavily on
//! Nicolas P. Rougier's freetype-gl project as well as Jukka's C++
//! implementation: https://github.com/juj/RectangleBinPack
//!
//! Limitations that are easy to fix, but I didn't need them:
//!

reillyeon

When does an async function return?

Someone recently asked me when an async function in JavaScript "returns". This is an interesting question because while a function like f() below has a return statement in it, f() actually returns much earlier than that. To understand how this works, let's take a look at an example function. Here, a() and c() are normal synchronous functions and b() is another asynchronous function.

async function f() {
  a();
  await b();
  return c();
}

mattdesl

If you're able to set up taquito locally, you can use the wallet.js code below to programmatically place pixels on my Spectrum Color board (hangzhou testnet).

Testnet contract:

KT1MeQytVramwMXJRyksTemX2B7qF4MJoRSG

Example:

(async () => {

mattdesl

import smartpy as sp

class SpectrumColors(sp.Contract):
    def __init__(self):
        self.init(
            # fixed dimensions of the board
            columns = 16,
            rows = 16,
            # limit to the total number of colors possible
            max_colors = 12,

slimsag

const std = @import("std");
const Allocator = std.mem.Allocator;

pub const Error = error{
    EndOfStream,
    Utf8InvalidStartByte,
} || std.fs.File.ReadError || std.fs.File.SeekError || std.mem.Allocator.Error;

pub fn Parser(comptime Value: type, comptime Reader: type) type {
    return struct {