shakesoda

I recently happened upon a very interesting implementation of popen() (different API, same idea) called popen-noshell using clone(2), and so I opened an issue requesting use of vfork(2) or posix_spawn() for portability. It turns out that on Linux there's an important advantage to using clone(2). I think I should capture the things I wrote there in a better place. A gist, a blog, whatever.

This is not a paper. I assume reader familiarity with fork() in particular and Unix in general, though, of course, I link to relevant wiki pages, so if the unfamiliar reader is willing to go down the rabbit hole, they should be able to come ou

Minimal D3D11

Minimal D3D11 reference implementation: An uncluttered Direct3D 11 setup + basic rendering primer and API familiarizer. Complete, runnable Windows application contained in a single function and laid out in a linear, step-by-step fashion that should be easy to follow from the code alone. ~200 LOC. No modern C++, OOP or (other) obscuring cruft. View on YouTube

Also check out Minimal D3D11 part 2, reconfigured for instanced rendering and with a smaller, tighter, simplified overall code structure, or Minimal D3D11 part 3, with shadowmapping + showcasing a range of alternative setup and rendering techniques.

Reducing build times by 20 % with a one line change

Experimenting a bit with the /d2cgsummary and /d1reportTime flags described by Aras here and here I noticed that one of our functions was consistently showing up in the Anomalistic Compile Times section:

1>	Anomalistic Compile Times: 2
1>		create_truth_types: 0.643 sec, 2565 instrs
1>		draw_nodes: 0.180 sec, 5348 instrs

	-- $Id: utf8.lua 179 2009-04-03 18:10:03Z pasta $
	--
	-- Provides UTF-8 aware string functions implemented in pure lua:
	-- * string.utf8len(s)
	-- * string.utf8sub(s, i, j)
	-- * string.utf8reverse(s)
	-- * string.utf8char(unicode)
	-- * string.utf8unicode(s, i, j)
	-- * string.utf8gensub(s, sub_len)
	--

	local glfw = require("glfw3") --Let's say we have a magic GLFW3 binding there!
	local openGL = require("opengl")
	openGL.loader = glfw.GetProcAddress
	openGL:import()

	--and somewhere else
	local vbo = ffi.new("GLuint[1]")
	gl.GenBuffers(1, vbo)
	gl.BindBuffer(GL.ARRAY_BUFFER, vbo[0])
	gl.BufferData(GL.ARRAY_BUFFER, ffi.sizeof(vertices), vertices, GL.STATIC_DRAW)

	// Mini memory editor for Dear ImGui (to embed in your game/tools)
	// Animated GIF: https://twitter.com/ocornut/status/894242704317530112

	// THE MEMORY EDITOR CODE HAS MOVED TO GIT:
	// https://github.com/ocornut/imgui_club/tree/master/imgui_memory_editor
	// Click "Revisions" on the Gist to see old version.

	/*
	* The MIT License (MIT)
	*
	* Copyright (c) 2016 Mario Badr
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is

	In shader programming, you often run into a problem where you want to iterate an array in memory over all pixels in a compute shader
	group (tile). Tiled deferred lighting is the most common case. 8x8 tile loops over a light list culled for that tile.

	Simplified HLSL code looks like this:

	Buffer<float4> lightDatas;
	Texture2D<uint2> lightStartCounts;
	RWTexture2D<float4> output;

	[numthreads(8, 8, 1)]