Count: 1737
1. Three.js for Learning Graphics Programming - An easy to use graphics lib for JS
2. Data Driven Rendering: Pipelines - A description of a simplified render graph, very well written, a lot of concepts that video games use are presented
3. Physically Based Rendering: From Theory to Implementation - Introduces concepts and theory of photorealistic rendering, includes code examples as well
4. Making WebGL Dance - Nothing WebGL specific, introduces core concepts in 3D graphics in a very attractive way
5. Shadertoy - A variety of cool examples of shaders running directly in the browser
6. Inigo Quilez's Website - Co-creator of Shadertoy, lots of interesting articles/videos/code samples
7. Raviramamoorthi - A lot of courses on computer graphics, especially ray tracing, but also stuff like OpenGL or 2D stuff
8. Bentley-Ottmann Algorithm - O((n+k) log n) algorithm for finding intersections of line segments
9. GPU Resources - A pretty big list of resources for GPU programming in general, includes stuff related to OpenCL/Cuda, Vulkan, WebGPU, Metal, SPIR-V, shading lanugages
10. Surfman - Low level rust library for managing surfaces using GPU memory, meaning render targets, can draw to a window, can draw to multiple windows, probably useful as a reference for implementing a window API
11. Designing An Object Oriented Animation Engine - A bit outdated, but probably useful as a reference for implementing an animation engine
12. Navier Stokes Equations - Useful for fluid simulations
13. Flutter's Rendering Pipeline - A look at some of the internals of Flutter
14. Inside Flutter - A deep dive into the inner workings of Flutter
15. OpenGL Projection Matrix - Presents how the projection matrix works
16. Rendering Course - From the 'Two Minutes Papers' guy
17. The Physics of Light and Rendering - From John Carmack, explains 3D concepts
18. How 3D Video Games Do Graphics - From Jonathan Blow, explains core concepts in 3D graphics
19. The Book of Shaders - A lot of stuff regarding fragment shaders
20. Ray Marching Terrain - Generating a very detailed scene with ray marching
21. Animate Your Way to Glory - How to use animations for a nice UI
22. Rainbowhung - Rain simulator, lots of resources in the 'credits' section
23. Rain and Water Effect Experiments - Generating rain effect with WebGL
24. Gilbert-Johnson-Keerthi Distance Algorithm - AKA GJK, useful especially for collision detection
25. Philip Rideout - Various computer graphics techniques
26. The Graphics Codex Book - Book on computer graphics, especially physically based rendering
27. Grphics Codex: Graphics Programming Projects - Projects to do to learn about computer graphics
28. Real-Time Rendering - Covering a lot of stuff on (duh) real time rendering, including curves and BRDFs(of course)
29. Computer Graphics from Scratch: A Programmer's Introduction to 3D Rendering - Building a renderer from scratch
30. Computer Graphics Learning Resources - List of useful links for computer graphics
31. BRL-CAD - Interactive geometry editing, high performance ray tracing and other stuff, probably useful as a reference for implementing something resembling a CAD
32. Google Filament: Description - Deep dive into the inner workings of Filament, useful even for an overview of physically based rendering in general
33. Materials Guide For Filament - Overview of the material types in Filament, useful to see al different kinds of materials for physically based rendering
34. Rendering Isometric Tiles - Easy to follow tutorial on how to render isometric tiles in 2D
35. An Interactive Introduction to Fourier Transforms - Title says it all
36. Painting a Selfie Girl, With Maths - Using ray marching to draw a character
37. How Software Gets Color Wrong - Presents how to represent color in software correctly
38. Hardware Effects on the GPU - How hardware affects performance on the GPU in various cases
39. Multithreading for Game Engines - Overview of an architecutre for game engines
40. GPU Architecture Resources - A lot of resources on how the GPU works
41. ASCII Simulation of Colliding Galaxies - Probably useful as a reference for implementing ASCII art
42. Is a Realistic Water Bubble Simulation Possible? - A relatively simple technique for generating bubbles
43. Exploring FPGA Graphics - Seeing how graphics work at the hardware level, uses SystemVerilog
44. Minecraft in 48 Hours in C - Easy to read source of a minecraft 'clone', probably useful as a reference for seeing how to render voxels
45. Nyuzi Processor: Experimental GPGPU Processor Hardware Design - Uses SystemVerilog and LLVM
46. Design Patterns for Low-Level Real-Time Rendering - Among other things, there are some cool tricks for ring buffers here, some tips fow working with aligned data for GPU access
47. Graphics Programming Weekly - Various articles on all kinds of stuff related to computer graphics
48. How Normal Mapping Works - Video explaining in quite some detail how normal mapping works
49. What Every Coder Should Know About Gamma - A very nice dive into gamma correction
50. An Introduction to Modern CMake - A very useful resource for learning modern practises for CMake
51. Real-World Dynamic Programming: Seam Carving - An easy to follow resource for implementing seam carving
52. Gitlet - Git in 600 Words - Learn how git workds under the covers, with code samples
53. Steganography Tutorial - Easy to follow, shows how to encode data in bitmaps
54. Minsk - Educational Compiler in C# - Illustrates basic concepts of compiler construction, also shows ways to expose APIs for parsing and type checking
55. Ugit - Learn Git Internals With Python - Interactive way to learn about git, shows code samples with diffing
56. Building Neural Networks From Scratch - Learn how neural networks function
57. DNS Basics And Building a DNS Server in Go - Useful to bettern learn about DNS servers
58. Deflate - Lossless data compression file format, used in gzip, PNG, ZIP
59. Vanilla Web Projects - Simple, useful projects that don't use any frameworks
60. Memory Barriers Are Like Source Control Operations - Useful to understand how memory barriers work
61. Weak vs. Strong Memory Models - Useful to understand how different memory models work for different architectures
62. This Is Why They Call It a Weakly-Ordered CPU - Concrete examples that show how a weak memory model affects a program
63. A Primer on Memory Consistency And Cache Coherence - Useful to better understand how caching works
64. An Allocator Is a Handle to a Heap - Clearing some thins up about manipulating allocators
65. Allocator Propagation Policies - Clearing up what happens when a move happens and custom allocators are involved
66. What a C Programmer Should Know About Memory - Useful to understand how virtual memory works
67. Project Based Tutorials in C - Lots of resources to learn C hands-on
68. Cryptography Is Not Magic - Very nice resource to learn about crypto algorithms
69. Improved Seam Carving With Forward Energy - A nice, easy to follow improvement to seam carving
70. Build Your Own Lisp - A nice way to learn compiler development
71. A Universal I/O Abstraction For C++ - A nice overview of networking in general for C++, also includes stuff about `io_uring`
72. Optimizing `string::append` Is Harder Than It Looks - A deep dive into implementing a standard-conforming `string::append`
73. Making The Tokio Scheduler 10x Faster - A real-world application of work stealing
74. High Performance Software Rasterization on GPUs - Sort-middle architecture for software rendering using compute shaders
75. How To Read Shader Assembly - Easy to follow overview on shader assebly
76. Massively-Parallel Rendering Of Closed-Form Implicit Surfaces - Rendering implicit surfaces(both 2D and 3D) on the GPU
77. Graphics Workshop - Learn computer graphics by writing shaders
78. Quickly Drawing a Rounded Rectangle With a GL Shader - Simple tutorial on how to draw rounded rects
79. Paxos Algorithm From The Ground Up - Learn the paxos algorithm interactively
80. Practical Byzantine Fault Tolerrance - Algorithm that is able to tolerrate Byzantine faults
81. Paxos - Family of protocols for solving consensus in an unreliable network
82. Notes On Paxos - May be useful to better understand the paxos algorithm
83. Diffie-Hellman Exchange For The Layman - Easy to understand explanation for Diffie-Hellman
84. Thread Pool With Coroutines - Work stealing implemented in C++, also useful to learn more about the coroutine API
85. Otokichi - Japanese that had to live on a drifting ship for 14 months
86. The Killer Whale Who Changed The World - Learning more about orcas
87. Listening to Whales: What The Orcas Have Taught Us - Learning more about orcas
88. Of Orcas And Men: What Killer Whales Can Teach Us - Learning more about orcas
89. Quick Search Algorithm(Boyer-Moore) - A simplification of the boyer-moore algorithm that is easy to implement
90. Moving Forth - Developing Forths for the 6809, 8051 and Z80
91. Modern C - A book on C from one of the editors of the C standard
92. Use Google Like a Pro - Searching on google tips and tricks
93. Awesome Music DSP - Curated list of resources for audio programming
94. Everything You Knew About Colour Is Wrong - How a lot of the times color is processed incorrectly
95. Speculating The Entire x86-64 Instruction Set In Seconds With This One Weird Trick - Very interesting read about x86
96. Rust Language Cheatsheet - Very useful as a quick reference
97. Site Map - Lots of resources for learning Rust(and not only Rust)
98. Copper - Go-style channels in C++, header-only, useful to learn more about concurrency
99. Children Of Chernobyl Cleanup Crew Don't Have Excess Mutations - A quick look at how radiatino affects DNA
100. Example RISC-V Assembly Programs - Useful to learn RISC-V assebly
101. IntegreSQL - Testing with a live Postgre database, does efficient recreating and pooling of databases
102. My Current HTML Boilerplate - Useful boilerplate for HTML for whenever starting a new project
103. Understanding Legal Argument: The Five Types of Argument - A nice introduction to legal arguments
104. The Technium - 99 additional bits of unsolicited advice
105. A Man Who Stole A Hotel - A very captivating read of a sad story of a ponzi scheme
106. SIMD For C++ Developers - A pretty in-depth tutorial on SIMD intrinsics
107. Cryptocurrency Is An Abject Disaster - Send this to anoyone who is excited about cryptocurrency
108. TRX: A Formally Verified Parser Interpreter - Useful to learn more about Coq and parsing in general
109. Verifying a Parser For a C Compiler - Useful to learn more about parsing in general
110. Validating LR(1) Parsers - Another great resource to learn more about formal verification and parsing
111. Functional Programming Jargon - Check this whenever you hear weird stuff from the FP world
112. Sorvagsvatn - Very beautiful lake in Feroe Islands that can trick your eyes
113. Cabana Valea Sâmbetei - În Munții Făgăraș, pare zonă frumoasă
114. Trasee Prin Piatra Craiului - Titlul spune tot
115. Lake Tahoe - Beautiful lake in US between California and Nevada
116. Jasper National Park - Very beautiful location in Alberta, Canada
117. Étretat - Very nice location near Le Havre
118. Pikes Peak - Very beautiful mountain, the place where some rally takes place
119. Lysebotn - A beautiful village in Norway
120. Trollstigen - A serpentine mountain road in Norway
121. Paxos Made Simple - Paxos explained in plain english
122. Raft Consensus Algorithm - Alternative algorithm to paxos
123. Move Semantics in C++ and Rust: The Case For Destructive Moves - Discussion about how destructive moves don't really fit for C++
124. Swash - Text shaping and rasterization, seems to have a readable codebase, probably useful as a reference if I want to implement something like this
125. Zeno - 2D vector graphics library, seems to have a readable(and small) codebase, probably useful as a reference
126. Computer Graphics From Scratch - Building two renderers(a ray tracer and a 3D rasterizer) from scratch
127. Scratchapixel - A lot of fundamental concepts in computer graphics explained, especially ray tracing(but not only)
128. Tiny Software Renderer - Software renderer in 500 lines of code
129. Bresenham's Run-Slice Line Drawing Algorithm - Another variant of Bresenham's algorithm, probably not too useful but still interesting to know
130. The Beauty Of Bresenham's Algorithm - Shows how the algorithm may be used to render more complex things like Bezier curves
131. SDL Universe - A simple, easy to understand software renderer
132. Developing a Software Renderer - An easy to understand tutorial on software rendering, also adds a pixel shader at some point
133. Real-Time Software Renderer in SDL - Title says it all, seems like the codebase is readable
134. Optimizing The Basic Rasterizer - Using SIMD to improve triangle rasterization, also has some chapters on depth buffers and general software rendering
135. A Simple And Trivially Parallelizable Triangle Rasterization Approach - Presents the method of rendering with barycentric coordinates, has nice visualizations
136. An Optimized Triangle Rasterizer - Parallelizable approach to triangle rasterization
137. A Sorting Classification Of Parallel Rendering - Rendering in parallel, present the sort-middle architecture
138. A High-Performance Software Graphics Pipeline Architecturefor the GPU - Software rendering on the GPU
139. SIMDRast - CPU rasterization using SIMD
140. SIMD Frustum Culling - Using SIMD for efficient frustum culling
141. Coroutines in C - How coroutines could be implemented in C
142. Standard C Library - Teaches how to implement libc, also contains design decisions about different things from libc
143. Computer Science From The Bottom Up - Title is a bit clickbaity, it teaches UNIX concepts
144. Category Theory For My Kid - I want to teach my 2 year old category theory, what do you think?
145. Internal Combustion Engine - Very nice overview of how ICEs work, with animations
146. How A Car Works - Paid course that goes pretty deep into how cars work
147. Cameras And Lenses - How pictures are taken
148. Lights and shadows - How lights and shadows work
149. Gears - How gears work
150. Alpha Compositing - Finally a good resource to learn about alpha compositing
151. Color Spaces - The ultimate guide to color spaces
152. Understanding Text Layout - Even though this is part of the book, the first chapter is really good for seeing some general stuff about text layout
153. Font Rendering With Vector Textures - A method that store curves in a grid for fast access in the fragment shader, renders directly on the GPU
154. GPU-Centered Font Rendering Directly From Glyph Outlines - The method that is used in the 'Slug' library
155. Text Rendering Hates You - Some things that are really difficult about text rendering
156. The State Of Text Rendering - Relatively old article, still useful
157. The Sad State Of Text Rendering In Linux - Pretty Opinionated, may still be useful
158. Easy Scalable Text Rendering On The GPU - A Method similar to Loop-Blinn but seems much easier to implement
159. An Introduction To Glyphs - Old but still relevant, shows what glyphs are made of
160. Requirements For Japanese Text Layout - Probably useful if you ever want to make a text renderer
161. Let's Stop Ascribing Meaning To Codepoints - Useful to see how unicode works
162. Dark Corners Of Unicode - Title says it all
163. Addition Font - Implementing addition using the GSUB table
164. Some Details About DirectWrite - A sneak peek of DirectWrite internals
165. Text Layout Is A Loose Hierarchy Of Segmentation - Design consideratinos for text layout
166. Fonts And Layouts For Global Scripts - A WIP book on text layout
167. Inside The Fastest Font Renderer In The World - Font rendering directly in an accumulation buffer, then calculating the prefix sum using SIMD
168. How The `stb_truetype` Anti-Aliased Software Rasterizer v2 Works - Good explanation of trapezoidal coverage
169. The `cl-aa` Algorithm - Explanation of the algorithm behind Anti-Grain Geometry
170. Libart Internals - Some of the inner workings of libart
171. Sub-Pixel, Gamma Correct Font Rendering - Title says it all
172. Unicode In 5 Minutes - Quick Overview Of Unicode
173. Unicode Programming, With Examples - Some common operations done on unicode strings
174. Distance Field Fonts - Code examples that show how to implement effects using signed distance fields
175. Improved Alpha-Tested Magnification for Vector Textures and Special Effects - Original Valve paper on signed distance fields
176. Font Rendering Philosophies Of Windows And MacOS X - Quick comparison of the renderers of these two platforms
177. Understanding Typography - Typography design considerations
178. Design Systems - Guides on correct color usage(and not only color, also general typography) for a beautiful design
179. Emojis Under The Hood - How emojis are represented
180. Infinite Resolution Textures - Some nice vector art algorithm
181. Rendering Vector Art On The GPU - The Loop-Blinn method
182. De Casteljau's Algorithm - An algorithm for dividing Bezier curves
183. GPU-Accelerated Path Rendering - NVPR, Nvidia's driver support for hardware-accelerated vector graphics
184. Drawing Thick Lines - Using the Bresenham's algorithm
185. Drawing Lines Is Hard - Showing how difficult it is to even draw a line correctly on the GPU, can be considered an overview of why 2D graphics are actually more difficult than 3D graphics
186. Drawing Anti-Aliased Lines In OpenGL - Drawing lines with anti-aliasing and miter joins in OpenGL
187. Shader-Based Anti-Aliased, Dashed, Stroked Polylines - Drawing dashed lines on the GPU
188. A Look At Pathfinder - How does Pathfinder work?
189. 2D Graphics On Modern GPU - An architecture for 2D graphics similar to RAVG and/or MPVG
190. Random-Access Rendering Of General Vector Graphics - RAVG, the successor to Loop-Blinn
191. Massively-Parallel Vector Graphics - MPVG, the successor to RAVG, uses a quadtree instead of a grid
192. Trapezoidal Decomposition - Decomposing an arbitrarily complex polygon into trapezoids
193. Introduction To Lyon: 2D Vector Graphics Rendering On The GPU - Describing the tesselator
194. Flattening Quadratic Bezier Curves - Efficient converting of Bezier curves to polylines
195. Drawing Bezier Curves - Subdividing Bezier curves, drawing them on iPhone
196. Drawing Anti-Aliased Circles In OpenGL - Using fwidth
197. Anti-Aliased Wireframe Rendering - Title says it all
198. Pathfinder Related Approaches - An overview of existing methods for rendering vector graphics
199. Fast 2D Rendering On GPU - An architecture for rendering 2D vector graphics on modern hardware, with some limitations
200. A Sort-Middle Architecture For 2D Graphics - Title says it all
201. Why Are 2D Vector Graphics So Much Harder Than 3D? - Some history of vector graphics and how it has become so difficult to render efficiently
202. How To Draw Oscilloscope Lines With Math And WebGL - Visualizing sound with WebGL
203. Canvas Drawing Techniques - A lot of brushes implemented, very useful if I ever want to make a painting app
204. The Principles Of Drawing With Maths - Drawing using ray marching
205. Line Joins Study - Different corner cases of line joins
206. Making A Heart With Maths - Ray marching
207. Painting A Flower With Maths In Google Sheets - Ray marching + Excel
208. Rounding Corners In SDFs - Getting some cool effects for shapes by rounding corners
209. Deriving The SDF Of A Line Segment - Getting some very cool shapes(like cilinders) just by modelling a line segment
210. A Primer On Bezier Curves - Everything Bezier curves
211. Path Tracing 3D Fractals - Fractals in 3D
212. Approximating Cubic Bezier Curves By Quadratic Ones - An efficient method for generating quadratic Bezier curves from cubic ones
213. 2D Vector Graphics Course - From one of the authors of MPVG
214. Efficient GPU Path Rendering Using Scanline Rasterization - Pretty complex(but fast) method for rendering vector graphics on the GPU
215. Filling Closed Bezier Paths - Easy to understand description of an algorithm for filling paths, unfortunately not numerically stable
216. Accelerating Vector Graphics Rendering Using The Graphics Hardware Pipeline - How Illustrator makes use of the GPU
217. An Algorithm For Computing The Shortest Distance Between A Point And A Quadratic Bezier Curve - Title says it all
218. Vector Texture Maps On The GPU - Rendering vector graphics using vector textures
219. Precise Vector Textures For Real-Time 3D Rendering - Rendering cubics directly, no approximations
220. Rendering Cubic Bezier Curves In GLSL - Might be useful as a reference
221. Image To Vector - Generating vector graphics from raster images
222. Tiny-Skia - A subset of skia ported to rust, might learn from its source code
223. Differentiable Vector Graphics Rasterization For Editing And Learning - Being able to retrieve exactly the same path data just from the rasterized image
224. Basic 2D Rasterization - An easy to understand tutorial introducing vector graphics(anti-aliasing, alpha compositing, gradients and others)
225. Vrmac Graphics Engine - Looks good at first sight, might be useful to check its source code
226. Fitting Cubic Bezier Curves - Algorithm for getting the closes curve to an existing one
227. Cleaner Parallel Curves With Euler Spirals - Simple and efficient way to get parallel curves
228. Understanding Rust as a C++ Developer - Concise article on some of the similarities/differences between Rust and C++
229. GUI From Scratch - Ideas for implementing GUI
230. Don't Fidget With Widgets, Draw! - A very intuitive interface for a GUI, old but relevant
231. SixtyFPS - UI framework similar to Qt(created by ex-Qt employees I think), much less feature rich but has an intuitive interface
232. Activity Indicators - Seems to have a readable codebase, might steal something from here when implementing activity bars in a GUI
233. TTauri - A lot of stuff implemented from scratch here, might be useful as a reference
234. Design Considerations For A Modern UI - Definitely worth checking out when implementing a GUI
235. Ray Tracing In One Weekend, The Next Week, Rest Of Your Life - Books on ray tracing, easy to follow, includes BVHs and other things
236. Ray Tracing In A Weekend With SYCL - Ray Tracing In One Weekend but this time with SYCL
237. Path Tracing In Compute Shaders Using OpenGL - Easy to understand, might be useful as a reference
238. Write A Raytracer Intuitively - Very easy to follow tutorial on ray tracing
239. Moller-Trumbore Intersection Algorithm - Algorithm for detecting ray intersections with triangles
240. Writing A GPU-Accelerated Path Tracer In Rust - Path tracing on the GPU
241. OpenCL Path Tracing Tutorial - Path tracing on the GPU using OpenCL
242. GPU Path Tracing - Using CUDA
243. Smallpt - Path tracing in 99 lines of C++
244. C-Ray - Easy to understand source for a path tracer, might be useful as a reference
245. Bidirectional Path Tracer - Real time in shadertoy
246. Path Tracing 3 Ways - Using FP, OOP and DOD to make a path tracer in C++
247. Ray Tracing A Tiny Procedural Planet - Drawing a plant using ray tracing
248. The Ray Tracer Challenge - Easy to understand book on ray tracing, includes some stuff on constructive solid geometry
249. RPT - Physically based path tracer in rust
250. Global Illumination Compendium - All maths behind ray tracing
251. GLSL Path Tracer - Path tracer entirely in a fragment shader, has some nice scene tests
252. Julia Quaternion - Ray marching a fractal in shadertoy
253. Rain Forest - Ray marching terrain in shadertoy
254. Ray Marching Signed Distance Functions - Title says it all
255. Building Collision Simulations: An Introduction To Computer Graphics - Includes a nice explanation of BVH
256. Bounding Interval Hierarchy - A slight improvement of BVHs
257. What Is Importance Sampling? - Explained
258. Sampling Microfacet BRDF - Some sampling theory
259. Monte Carlo Integration With Multiple Importance Sampling - An explanation of importance sampling
260. Importance Sampling - Deep dive into importance sampling
261. Ray Marching ASCII Graphics - Generating ASCII art
262. Yocto/GL - Data-Oriented physically based rendering, might be useful as a reference
263. Catala - Programming language for the law
264. Vulkan Tutorial - Shows a lot of stuff about vulkan in an easy to understand way
265. `debug_printf` - Debugging helper for Vulkan
266. Mesh Shaders - A different kind of shader
267. Writing An Efficient Vulkan Renderer - Design considerations for a Vulkan renderer
268. ANARI - Analytic Rendering Interface for Data Visualization
269. Vulkan Guide - An easy to understand tutorial on Vulkan
270. The Projection Matrix In Vulkan - Title says it all
271. ArrayFire - GPGPU cross-platform library
272. Parallel Reduce And Scan On The GPU - Title says it all
273. Prefix Sum On Vulkan - Title says it all
274. Parallelizing GPU-Intensive Workloads Via Multi-Queue Operations Using Vulkan Kompute - Do more stuff in parallel with a multi-queue operation
275. WebGPGPU - Bits of image processing in WebGL
276. Fix Your Timestep - Designing a main loop for a game correctly
277. Using Rust For GameDev - General advice for using Rust for gamedev
278. Permafrost Game Engine - RTS game engine, might be useful as a reference
279. CGAL - Computational geometry library
280. Triangulation By Ear Clipping - Ear clipping explained
281. Efficient Polygon Triangulation - Code example of polygon triangulation
282. FITS: Fast Industrial-Strength Triangulation Of Polygons - Ear clipping algorithm
283. Delaunay Triangulation - A more efficient triangulation algorithm
284. Triangulation Using The Stencil Buffer - Quick hack
285. Computational Geometry: Algorithms And Applications - Book on computational geometry
286. Fast Fluid Simulations With Sparse Volumes On The GPU - Method for rendering fluids on the GPU
287. Fast Fluid Dynamics Simulation On The GPU - Fluid simulation on the GPU
288. WebGL Fluid SImulation - Might be useful as a reference
289. Understanding Quaternions - Quaternions for the layman
290. Let's Remove Quaternions From Every 3D Game Engine - Better understanding quaternions
291. Designing A Physiscs Engine - Physics engine design considerations
292. Maths Library For C++ - Useful for games, has a readable codebase, supports swizzling
293. Simple Mesh Math For Complex Geometry Operations - Fun with matrix multiplications
294. How To Securely Hash Passwords - Discussion on storing passwords
295. History Of Programming Languages - _Lots_ of resources for studying how various paradigms in PL have evolved
296. Rustonomicon - All the awful details that you need to understand when writing unsafe Rust
297. Storseisundet Bridge - Norway
298. Linux Device Drivers - Writing drivers for Linux
299. HTTP/3: The Past, The Present, And The Future - Discussion on what advantages QUIC has over TCP
300. Satul Cobor - Brașov
301. Cabana Diham - Munții Bucegi
302. Măgura, Brașov - Mica Elveție, sat situat la poalele munților Bucegi și Piatra Craiului
303. Web Dev For Beginners - Learn by practising, includes quizzes
304. Ineleț, Caraș-Severin - Foarte izolat, se poate ajunge acolo doar pe o scară de lemn, sau un drum de 4 ore aproape de Băile Herculane
305. Stâna din Grind - Munții Piatra Craiului
306. Graphics Resources - A huge collection of resource for computer graphics, kind of similar to mathpages
307. Rayground - Ray tracing prototyping on the web
308. Refractiveindex - All the refractive indexes you need
309. Rotation Issues - Discussion on different rotation methods
310. 3D Game Shaders For Beginners - SSAO, depth of field, lighting, normal mapping and others
311. Importance Sampling For Production Rendering - Explaining (multiple) importance sampling and all the statistics behind it
312. Intuitive Idiot-Proof Validation Of Importance Sampling For Monte Carlo Computations - Explaining importance sampling
313. I Am Graphics And So Can You - Diving into graphics programming (and Vulkan) for non-experts
314. Higher Level Threading In C++ - Multithreading primitives explained
315. Error Handling In Rust: A Deep Dive - Practical error handling in rust with examples
316. C++20 Coroutines: Under The Hood - Thoroughly understanding coroutines in C++
317. Starting FORTH - The classic Forth tutorial
318. Thinking Forth - Another Forth classic
319. Learn You Some Erlang For Great Good - Intuitive tutorial on Erlang
320. Kuro - Practical usage of coroutines with examples
321. How The Pfizer BioNTech Vaccine Works - A more detailed view over the vaccine
322. Debug Symbol - HUGE debug symbol, welcome to C++
323. The Ultimate Guide To Inflation - Title says it all
324. A CRDT Primer Part I: Defanging Order Theory - Series of articles presenting CRDTs
325. Leaota - Vârf pe care se poate ajunge cu mașina
326. The Feynman Lectures On Physics - Proper way to learn physics
327. Verification = TCB/PB Reduction - What does it mean to formally verify something?
328. Render Graphs And Vulkan, A Deep Dive - Title Says It All
329. Taking State Transitions In Vulkan And Direct3D12 Under Control: A Dilligent Approach - State management and synchronization
330. Polar Stroking: New Theory And Methods For Stroking Paths - Render stroked paths robustly, intuitively
331. Converting Stroked Primitives To Filled Primitives - From one of the authors of MPVG
332. A High-Level View Of TLA+ - Learning TLA+ from Leslie Lamport Himself
333. Idris Tutorial - Learning Idris
334. Dependent Types As Macros - Implementing dependent types using just macros
335. Neut - Programming language without GC, with dependent types
336. Using TLA+ In The Real World To Understand A Glibc Bug - Practical TLA+
337. Software Foundations - Mathematical underpinnings of reliable software
338. Verified Programming In F* - A nice intro to formal verification
339. Comparison Of Two Theorem Provers: Isabelle/HOL And Coq - Includes an overview of logic
340. Seemingly Impossible Functional Programs - Some intersections between maths and FP
341. Applied Type System: An Approach To Practical Programming With Theorem Proving - Practical tutorial for ATS
342. Formal Methods Of Software Design - Using maths to write error-free programs
343. Introduction To The Coq Proof Assistant For Practical Software Verification - Practical tutorial on Coq
344. Certified Programming With Dependent Types - Tutorial on formal verification
345. The Pitfalls Of Protocol Design - Attempting to write a formally verified PDF parser
346. Archive Of Formal Proofs - Huge list of formal proofs
347. Formal Proof Of The 4-color Theorem - Using coq
348. Meet The Robinson: An Introduction To Automatic Theorem Proving - Title says it all
349. TLA+ Action Properties - A deeper dive into TLA+
350. TLA+ In Practice And Theory - Learning formal methods with TLA+
351. Logic And Computation Intertwined - Proofs and their applications in computer science
352. Introduction To Coq - Hands-on intro to Coq
353. TLA+ Graph Explorer - Tool for viewing TLA+ state graphs
354. Rebooting The LMARV-1 RISC-V Project - Formally verified RISC-V CPU
355. DataType99 - Algebraic Data Types for C99
356. Vulkan In 30 Minutes - Short overview of vulkan
357. Chocopy - An educational compiler to RISC-V for a subset of python
358. Kaleidoscope - Making a programming language with LLVM
359. Basics Of Compiler Design - A lot of stuff that you would need to know if you want to make a compiler, includes register allocation and code generation
360. Regex Matching Can Be Simple And Fast - A very nice tutorial on how regex matching doesn't have to be complicated
361. Let's Build A Simple Interpreter - A very easy to follow on building an (incomplete) expression parser
362. Let's Build A Compiler - Non-technical intro to compiler construction(the front-end part)
363. Selfie - Educational repo consisting of a self-compiling C compiler, a self-executing RISC-V emulator and a RISC-V hypervisor
364. NFA To DFA Converter - Title says it all
365. Build Your Own Webassebly Compiler - Fantastic talk, nothing to add
366. A Pretty But Not Greedy Printer - Reasonably efficient pretty printer implementation
367. A Pretty Printer - Functional description of a pretty printer
368. The Hardest Program I've Ever Written - Discussion on why pretty printers are difficult to implement
369. A Crash Course On Compilers - A simple overview of what compilers are made of
370. Why Parsing Tools Are Hard - Discussion on parsing tools
371. A Compiler Writing Journey - Lots of lessons covering almost everything for writing a compiler
372. Pratt Parsers: Expression Parsing Made Easy - Explaining pratt parsers
373. Crafting Interpreters - Probably the best overall book on implementing an interpreter
374. Compiling To Assembly From Scratch - A book that covers every part of the compiler
375. Micro C - Writing a compiler for a small subset of C to LLVM in haskell
376. A New Architecture For Building Software - Improving compile times in LLVM
377. Build Your Own WebAssebly Compiler - Learning more about webassembly and compilers
378. Metacompilers - Writing compilers inside web pages
379. Pika Parsing - Reformulating packrat parsing as a dynamic programming algorithm solves the left recursion problem
380. A Hitchhiker's Guide To Reinventing A Prolog Machine - Fresh look at implementing prolog
381. Warren Abstract Machine - Abstract machine for executing prolog
382. C Internals - Seeing how C translates to assembly behind the scenes
383. Tree-Sitter - Framework for incremental parsing, it would probably be cool to check it's source code
384. How JIT Compilers Are Implemented And Fast - Seeing how JITs work
385. LuaJIT Doc - Describing how LuaJIT works
386. How Relocations And Thread Local Store Are Implemented - How the compiler takes in account thread local store
387. Adventures In JIT Compilation - Building an interpreter for brainfuck
388. Abstract Syntax Tree Representation - Discussion on how an AST might be represented
389. Parsing Algorithms - Title says it all
390. Building An Interpreter From Scratch - Title says it all
391. Make A Programming Language In Rust - Front-end for a compiler, in rust
392. Simple But Powerful Pratt Parsing - Pratt parsing explained
393. Implementing A JIT Compiled Language With Haskell And LLVM - Title says it all
394. Write You A Haskell - Building A Modern Functional Compiler From First Principles
395. Advanced Compilers - The Self Guided Online Course
396. Essentials Of Compilation - Compiling a subset of racket to x86-64 assembly
397. A Complete Guide To LLVM For Programming Language Creators - Title says it all
398. Inline Caching - Technique for runtime optimization
399. SheCC - Educational self hosting C compiler
400. Course Webpage For Compilers - Translating Racket to x86 assembly
401. Linkers - Series describing how to make a linker
402. Implementing A Bignum Calculator - By Rob Pike
403. The Missing Link - Explaining ELF Static Linking, Semantically
404. Toolchains.net - Lots of resources for implementing linkers(and other stuff) or for contributing to clang(even GCC)
405. Compiling A Lisp - Tutorial on implementing a Lisp compiler
406. Engineering A Compiler - Alternative To The Dragon Book
407. A History Of APL In 50 Functions - Learning APL step by step
408. Zen - Programming language that compiles down to C++
409. Unison Programming Language - A programming language where code is immutable
410. Type Equality In LLVM - Low level details of LLVM
411. Hindley Milner Type System - Based on lambda calculus with parametric polymorphism
412. What Every C Programmer Should Know About Undefined Behavior - Title says it all
413. Linear Types Can Change The World - Deep dive into linear types
414. Javascript For Kids - Learning JS with graphics
415. Hands-On WebAssembly - Learn webassembly step by step
416. What I Wish I Knew When Learning Haskell - Things to know about haskell
417. Brzozowski Derivatives - Converting from e-NFA to DFA directly
418. The Most Commented Linker Script In The World - Learning more about linker scripts
419. 99 Prolog Problems - Learning prolog through simple problems
420. The Power Of Prolog - Learning Prolog
421. WTF Python - Seeing lots of dark corners of Python
422. Practical Go Lessons - Includes a nice chapter on profiling
423. Effective Go - Various concepts in Go explained
424. What Are The Practical Implications Of Homotopy Type Theory In Programming? - Title says it all
425. Cateory Theory For Programmers - Book on category theory
426. HoTTSQL - Using Homotopy Type Theory to optimize SQL queries
427. Poetry - Python tool for managing environments
428. AST Explorer - See the AST of various programming languages/markup languages
429. Dhall Configuration Language - DRY config language
430. Feral Language - Minimal dynamically-typed language, seems to have a readable codebase
431. MiniKaren - DSL for logic programming
432. WebAssembly Studio - Online IDE for webassembly
433. Atomics In AArch64 - Dissecting the performance of a simple atomic operation on a couple of ARM AArch64 machines
434. Modern Javascript: Everything You Missed Over The Last 10 Years - Quick view of new features in JS
435. How Music Works - Learning Music Theory
436. So You Want To Learn Physics... - Good resources for learning physics
437. Securing PostgreSQL - Title says it all, might be applicable to any database
438. Noone Knows The Type Of `char + char` - C++ dark corner
439. Memory Model Synchronization Modes - Explaining memory order for atomics
440. How I Declare My Classes And Why - Tips on C++ good practice
441. Volatile: The Multithreaded Programmer's best friend - How volatile helps with multithreading
442. C++ 'You Can Do That!' Moments - Interesting discussion on C++
443. C++ Quizzes - Title says it all
444. The C++ Memory Model: An Intuition - Good, concise talk on the memory model of C++
445. The Performance Benefits Of Final Classes - Title says it all
446. C++ Standard Draft - Up to date draft of the ISO C++ standard
447. Is C++ Context-Free Or Context-Sensitive? - Interesting discussion on the syntax of C++
448. C++ Annotations - Modern, up to date intro to C++
449. Constexpr Function Parameters - How to pass compile-time parameters to functions
450. Compiler-Neutral Internal Program Representation For C++ - Internal Program Representation for C++ programs
451. Boyer Moore Searcher With Rytter Correction - Discussion on boyer moore searcher
452. A Generic, Extendable And Efficient Solution For Polymorphic Programming - An alternative to inheritance-style polymorphism
453. Deterministic Exceptions - (Better) Alternative to the current exception mechanism in C++
454. Barton-Nackman Trick - Relying On CRTP To DRY Yourself
455. `std::noop_coroutine` - How to implement a basic `task<T>`
456. `std::coroutine_traits` - How to implement basic continuation for `std::future`
457. `std::coroutine_handle` - How to implement a basic `generator<T>`
458. All C++20 Core Lanugage Features With Examples - What every new feature in C++20 has to offer
459. Web Design In 4 Minutes - Quick interactive intro to web design
460. How To Design A Sailing Ship For The 21st Century - What makes a good sailing ship
461. Generate Stepper-Motor Speed Profiles In Real Time - Algorithm for stepper-motor acceleration
462. Safe Numerics - How safe numerics is useful for embedded, includes a lot of good practice for embedded in general
463. WebGL Fundamentals - A good 3D tutorial on WebGL(could be considered for OpenGL as well)
464. Compute Shaders 101 - Getting started with compute shaders in Rust
465. Liberating Distributed Consensus - Viewing the underlying concepts of paxos
466. Paxos Vs. Raft: Have We Reached Consensus On Distributed Consensus? - Comparing paxos and raft
467. Neat Algorithms: Paxos - A very friendly introduction to paxos
468. Raft: Understandable Distributed Consensus - Visualizing raft step by step
469. Principles Of 2D Graphics - Lots of resources for vector graphics
470. Color Vision - A very comprehensive resource on color
471. Woboq - Code browser for C++
472. KFR - Library for C++ audio and DSP
473. Coat - C++ DSL for JIT code generation
474. Mimalloc - An efficient memory allocator
475. Getting Rid Of (Some Of) Volatile In Qt - Use cases where volatile might not be such a good fit
476. List Of C++ UI Libraries - A huge list of libraries for UI for C++
477. Botan - Crypto and TLS for modern C++
478. CPP-HTTPLib - A very easy to use library for HTTP
479. CPP-PEGLib - Easy to use library for parsing given an expression grammar or by using parser combinators
480. CMake Line By Line - How to use a non-cmake library
481. MatPlotPlusPlus - Matplotlib-like lib for C++ for data visualization
482. LunaSVG - SVG renderer
483. PlutoVG - Standalone library for rendering vector graphics C++
484. Concurrencpp - C++ concurrency library with coroutines and executors, might be useful to look at its source
485. BeastHttp - Library for building REST APIs on top of boost.beast, looks unmaintained but it may be useful as a reference
486. Doxygen Awesome CSS - Some cool themes for Doxygen, similar to vuepress
487. HDoc - The modern documentation tool for C++ with more beautiful output than doxygen
488. An Interactive Guide To The Fourier Transform - Easy to follow guido on fourier transforms
489. Tone Mapping - Understanding what tone mapping is
490. Learn CSS - An in-depth tutorial on CSS, the website also includes various others tutorials(including for React and Angular)
491. Graphics Pipelines For Young Bloods - Explaining forward rendering, deferred rendering, z-prepass and comparing their advantages/disadvantages
492. Discussion on VSCode LSP Architecture - Guy that works on IDE support for rust explains why VSCode has a better LSP integration than nvim
493. Building A Thread-Pool With Coroutines - Practical tutorial on coroutines
494. C++20 Coroutines In Action - Understand C++ coroutines by exxample
495. Copper - Go channels implemented in C++ with coroutines
496. Effective Modern CMake - A very good tutorial on how modern CMake should be written
497. Oceans Of Kansas - Book on paleontology
498. Professional CMake - Complete Book on modern CMake
499. `<random>` - Discussion on misconceptions of `<random>`
500. Simple Scripting VM Example - Crafting Interpreters implemented in C++
501. A Language Lawyer Story - A good C++ meme
502. C++ Learning Resources For Audio - Collection of helpful tutorials/books on audio
503. JIT Compilers - Discussion on why JIT can do certain optimizations AOT compilers can't
504. Stackless Vs. Stackful Coroutines - Discussion on why these names create confusion
505. C++ Coroutine API Is Complex For Library Writers, Not Consumers - Discussion on why the coroutine API in C++ being so low-level can be an advantage
506. SDF Can Be Made More Accurate For Rounded Corners - Discussion on how SDFs for text rendering can be improved by not using a rasterized font as the base
507. Rust Explanations For Box, Arc, Rc And All The Others - Discussion presenting every one of them in an easy to follow way
508. Negative Time Durations Are Useful - Discussion on how C++ is right to have the possibility of negative durations
509. Postgre Helpers - Two lines that can save you in production
510. Why Not Rust? - A list with some of the downsides of rust
511. In The Deep Sea, Incredible Animals Abound - Some creatures that can be found in the deep
512. Computing An Integer Using A Grothendieck Topos - Formalizing maths
513. How To Get Started With Audio Programming - Various resources for audio programming
514. Stadlandet - Norway
515. It's Probably Time To Stop Recommending Clean Code - Why 'Clean code' may not be that good
516. WASM Synth, Or, How Music Taught Me The Beauty Of Math - Building a synth with C++ and WebAssembly
517. Pianoteq - Create and mix hybrid instruments with stunning authenticity
518. Signals And Systems - System theory
519. General System Theory - Title says it all
520. Cybernetics, Second Edition: Or The Control And Communication In The Animal And The Machine - Book on cybernetics and robotics
521. Rare Vietnam War Images From The Winning Side - A taste of how life was there at the time
522. Let's Build A Regex Engine - Easy to follow tutorial on how to implement a regex engine
523. Building A RISC-V CPU From Scratch - How somebody built a RISC-V CPU
524. That Time Hitler's Girlfriend Visited Iceland And The British Invaded - Story on Iceland during WW2
525. C Is Not A Low-Level Language - Discussion on how C is not a portable assembly
526. SQL Query Optimization: Understanding Key Principle - A dive into SQL query optimization
527. SQL Indexing And Tuning E-Book - How to tune queries
528. Idiosyncracies Of The HTML Parser - Gotchas of HTML parsing
529. Structural Typing In Rust - Some hackery to achieve structural typing in Rust
530. Elliptic Curve Cryptography Explained - How ECC works
531. How To Interpret PostgreSQL Explain Analyze Output - Details on `EXPLAIN`
532. Building A Raft - Understanding the Raft algorithm
533. RefinedC - Automating The Foundational Verification Of C Code With Refined Ownership Types - C with ownership types and refinement types, producing a proof of program correctness in Coq
534. Why Specifications Don't Compose - Title says it all
535. UUID, Serial Or Identity Columns For PostgreSQL Auto-Generated Primary Keys? - Benchmarking the various approaches for storing primary keys
536. Rotations With Quaternions - Easy to follow tutorial on quaternions
537. A Firehose Of Rust, For Busy People Who Know Some C++ - Learning Rust as a C++ developer
538. Colibița - Bistrița-Năsăud
539. Awesome Modern C++ - Collection of high quality resources for modern C++
540. Implementing An Outbox - Model-Checking First - Using TLA+ to prove consistency between database and messaging operations
541. Pathfinder, A Fst GPU-Based Font Rasterizer In Rust - Description of the algorithm used in pathfinder 1.0, it uses compute shaders to flatten curves and the trapezoidal pixel coverage algorithm
542. Anatomy Of A Linux DNS Lookup - Deep dive into DNS lookup on linux
543. Computing The Number Of Digits Of An Integer Even Faster - Tricks for the algorithm
544. FTXUI - Terminal user interface library, might be useful to check it's flex layout implementation
545. 50% Reduction Of Krill In Past 6 Decades - North Atlantic warming over six decades drives decreases in krill abundance with no associated range shift
546. Advanced R - Book on R, focuses on the gotchas of the language, explains core concepts really well, eliminates a lot of confusion on R
547. Using Scheme To Find The Median Of Two Sorted Integer Lists - A nice introduction to scheme
548. How Does A USB Keyboard Work? - Deep dive into how USB keyboards work
549. CryptoPals - (WIP) Implementing crypto algorithms
550. Clash Lang - Functional hardware description language, based on haskell
551. Clash Tutorial - Intro to clash(and HDLs in general)
552. Conway's Game Of Life On FPGA - Scala implementation for GOL that runs on an FPGA
553. Locally Scaled Domain Coloring: Contour Plots - Useful if I ever want to plot functions
554. RISC vs. CISC Is The Wrong Lens For Comparing Modern x86 ARM CPUs - Some history + some diving into how CPUs work
555. RISC vs. CISC - Another overview
556. USB Made Simple - How USB works
557. CPP Starter Project - Modern template for modern C++ projects, useful practices for CMake, testing, fuzzing, packaging, coverage, etc.
558. Handling Async Requests Using Futures - Quick intro to async primitives in C++
559. Hardware Effects - Illustrating various effects on the hardware like false sharing, cache conflicts, hardware prefetching, etc.
560. Wait-Free Ring Buffer - Quick implementation in C++ from boost docs
561. I Accidentally Wrote A Compile-Time Executable State Machine - Design for a state machine library in C++, can also be executed at compile time
562. Fun With `std::thread` - Includes a simple implementation of thread pools
563. Dead Simple Markov Sentences - Easy to follow source code for saving and loading markov chains
564. Obfuscated C Primer - Guide on C obfuscation
565. Correctly Implementing A Spinlock In C++ - Gotchas to take care of when implementing a spinlock
566. Parallel HashMap - Presentation of the performance of abseil's `flat_hash_map`, includes a bit of code
567. An Entity Component System In C++ With Data Locality - Step by step tutorial on implementing an ECS with C++(archetypes)
568. High Performance Garbage Collecion With C++ - Some of the internals of V8
569. Build A Simple 2D Physics Engine For Javascript Games - Friendly intro to physics engines with JS
570. An Introduction To Parallel Computing In C++ - Building blocks for parallelism, step by step tutorial
571. C++ - Crafting Interpreters - Code for 'Crafting Interpreters' in C++
572. MPI Tutorials - Collection of articles on MPI
573. 3D D3D11 Game Engine From Scratch - Youtube playlist of a guy implementing a game engine from scratch
574. FP Library - Implementation of Ryu for C++
575. Practical Parallelism In C++ - Tutorials on parallelism in C++
576. Generating Random Numbers Using The C++ Standard Library: The Problems - Problems with random number generation primitives in the C++ standard library
577. Developing A `seed_seq` Alternative - Deep dive into random number generation
578. C++ Tip Of The Week - 'Did you know...?' kind of tips for modern C++(with examples)
579. C++20 Coroutines: Sketching A Minimal Async Framework - Real world example usage of C++ coroutines
580. My Tutorial And Take On C++ Coroutines - Another tutorial on coroutines
581. Coroutines Introduction - Title says it all
582. Deep Dive Into Coroutines - Coroutine theory
583. Parameter Passing In C And C++ - How parameters are passed behind the scenes
584. Lock-Free Job Stealing With Modern C++ - Implementing a work-stealing thread pool in C++
585. Understanding Atomics And Memory Ordering - Light introduction to memory ordering
586. C++ Event Listener - Simple idea for implementing an event listener in C++
587. NasNas - 2D Game Framework For C++, has a readable codebase, might learn some practises
588. FlapHero - Game for Android and iOS made using plywood, might learn some practises
589. SixtyFPS - Qt-like GUI framework for C++, Rust and others
590. Ray Tracing In Pure CMake - Fun with CMake
591. Encoding MIPS Instructions With C++17 - Tutorial on writing an assembler in C++
592. `riften::Thiefpool` - Work-stealing implemented in C++
593. `taskflow/tsq.hpp` - Work-stealing as it's implemented in cpp-taskflow
594. Lock-Free Programming (Herb Sutter) - How to use atomics correctly
595. Type Deduction And Why You Care (Scott Meyers) - Everything to know about type deduction in C++
596. Garbage In, Garbage Out: Arguing About Undefined Behavior... (Chandler Carruth) - Thinking about undefined behavior in a productive way
597. Practical C++17 - Using C++17 features effectively
598. War's Unwomanly Face - Book about wars
599. Life And Fate - By Vasily Grossman
600. A Random Walk Through Git - In-depth look at how git works
601. 105 STL Algorithms In Less Than An Hour - Shows what is inside `<algorithm>`
602. CPU Caches And Why You Care (Scott Meyers) - How to make use of the cache, _very_ engaging talk
603. Esoteric Data Structures And Where To Find Them - Some more niche data structures
604. Data-Oriented Design And C++ - How to think in terms of data oriented design
605. So, You Inherited A Large Code Base... - Advice for working on large codebases
606. Local 'Arena' Memory Allocators - Title says it all
607. How We Get To Main - What happens behind the scenes before `main` is called
608. Rust: Hack Without Fear - Rust presented for C++ programmers
609. Getting Allocators Out Of Our Way - Understanding the additions of C++17's pool memory resource, shows how to implement an allocator the modern way
610. Benchmarking C++ Code - Showing the maths behind good benchmarking
611. Understand The C++17 PMR Standard Allocators And Track All The Things - (Again) Understanding what C++17 has to offer in terms of memory allocation
612. `std::allocator` (Andrei Alexandrescu) - Presents a very nice, composable design for allocators, applies not only to C++
613. An Interesting Lock-Free Queue - Design considerations for a lock-free queue
614. Recreational C++ - Implementing stuff in C++, various corner cases shown, fun talk
615. Speed Is Found In The Minds Of People (Andrei Alexandrescu) - Fun with sorting
616. How To Implement Your First Compiler Feature: The Story Of Concepts In Clang - How to hack on clang
617. C++ Atomics: From Basics To Advanced - Thoroughly understanding atomics in C++, explains really well memory ordering
618. Java Concurrency: Basics Of Threads - Quick intro to threads in Java
619. Effective Java 3rd Edition - Book on Java
620. Java MOOC - University of Helsinki's course on Java
621. Java 'Back To Basics' - Baeldung
622. A Categorized List Of All Java And JVM Features Since JDK 8 To 17 - Title says it all
623. Z Garbage Collector In Java - ZGC now has O(1) pausing(and a pause takes no more than 1ms)
624. A Half-Hour To Learn Rust - Quick intro to Rust
625. Easy Rust - Easy to follow tutorial on Rust
626. Learn Rust With Entirely Too Many Linked Lists - Learning rust the hard way
627. Rust's Type System Is Turing Complete - Just like C++'s
628. Crust Of Rust: Channels - Implementing channels in Rust
629. Crust Of Rust: Atomics And Memory Ordering - Understanding atomics in Rust
630. Poiana Sibiului - Sibiu
631. Cabana Cozia - Vâlcea
632. Cascadele Beușniței - Caraș-Severin
633. Cascada De La Vadu Crișului - Bihor
634. Havasu Falls - Arizona
635. Scheduling Multithreaded Computations By Work Stealing - The original paper on work stealing scheduling
636. FizzBuzz In Tensorflow - Even though it's a joke, it can be seen as a gentle introduction to tensorflow and ML in general
637. Kalyn: A Self-Hosting Compiler For x86-64 - How some guy implemented a lisp-like compiler that is self-hosted from scratch
638. ATS: Why Linear Types Are The Future Of Systems Programming - An overview of ATS
639. Notes On Some PostgreSQL Implementation Details - Deep dive into postgre, seeing how one can actually scale postgre
640. Klein - C++17 SIMD library, probably useful to just check its source
641. SIMD Quicktip: Understanding 16 Byte Memory Alignment Detection - Simple instruction to check whether a pointer is 16 byte aligned
642. How To SIMD - Simple program to illustrate SIMD functionalities
643. Pure SIMD - SIMD library with some nice constructs built in, probably useful to see how they're implemented
644. Faster Integer Parsing - Using SIMD to parse integers quickly
645. Intel Implicit SPMD Program Compiler (ISPC) - C-Based programming language that makes us of SIMD, even though the code looks serial
646. Teddy - SIMD accelerated substring matching algorithm
647. SIMD Instructions - Used to be a list of SIMD relaed stuff, at least HN comments remain
648. `is_sorted` Using SIMD - Shows how to implement `is_sorted` making use of SIMD
649. Practical SIMD Programming - Explains SIMD by implementing examples that can make use of it
650. In-Place Super Scalar Samplesort - Parallel comparison-based sorting algorithm, also in-place
651. AVX-512 Mask Registers, Again - How AVX-512 looks at a hardware level
652. x86 Intrinsics Cheat Sheet - Title says it all
653. SIMD Everywhere - Library that implements intrinsics on hardware that doesn't support them natively, using the native intrinsics otherwise
654. Improving Performance With SIMD Intrinsics In Three Use Cases - Practical uses of SIMD
655. C++ SIMD Proposal - How a potential library for SIMD would look for C++
656. Programming With RISC-V Vector Instructions - How RISC-V vector instructions look like
657. Intrinsic Functions: Vector Processing Extensions - SIMD tutorial implementing the Mandelbrot fractal, very easy to follow
658. My First SIMD - Implementing STL Algorithms Using AVX2 extensions
659. Building Faster AMD64 Memset Routines - Making `memset` faster
660. FizzBuzz: SIMD Style! - The new Java SIMD API
661. How To Write A Basic Control Flow Decompiler - How to write a general decompiler for control flow of a given sub function
662. How I Reverse Engineered Google Docs To Play Back Any Document's Keystrokes - Title says it all
663. Reverse Engineering The Source Code Of The BioNTech/Pfizer SARS-CoV-2 Vaccine - Title says it all
664. Breaking The x86 Instruction Set - Fun With x86, very entertaining talk
665. D* Lite - Algorithm for real-time path finding
666. Continuum Crowds - Real time motion for crowds
667. Introduction To The A* Algorithm - Easy to follow tutorial on A*
668. Painless C++ Coroutines - Understanding coroutines
669. Castle Mountain - Canada
670. The Memory Models That Underline Programming Languages - A lesson on how various principles of programming languages work
671. Wrapper Types In Rust: Choosing Your Guarantees - Learning about `Rc<T>`, `Arc<T>`, `Cell<T>`, `RefCell<T>`, `Mutex<T>`, `RwLock<T>`
672. Deep Javascript - Learning the ins and outs of javascript
673. How You Average Numbers Matters - How to average floating points correctly
674. Calculus By And For Young People - Explaining calculus to 7 year olds
675. Introduction To Univalent Foundations Of Mathematics With Agda - HOTT in agda
676. Reflections On Trusting Trust - Write a program that prints itself
677. Debugging A Flaky Test With RR - How to use rr
678. Fitting A Forth In 512 Bytes - Bootstrapping a computer using forth
679. Applied Deep Learning - Practical courses on deep learning
680. Is HOTT The Way To Do Mathematics? - Formalizing maths
681. Introduction To Homotopy Type Theory - Not a final version, might still be useful
682. In Further Praise Of Dependent Types - 'Mathematicians use dependent types, even though they don't know they are using dependent types'
683. Vârful Lui Roman - Munții Carpați, se poate ajunge cu mașina
684. Introduction To WGPU - Learning WGPU(rust)
685. Vârful Picuiata - Munții Făgăraș
686. Calculus Made Easy - Classic intro to calculus
687. Mathematical Methods For Physics And Engineering: A Comprehensive Guide - Using mathematical methods for parctical purposes
688. Calculus, 4th Edition - Real analysis, not easy to read but probably worth it
689. Advanced Calculus: A Differential Forms Approach - Well written book, probably for researchers
690. Introduction To Abstract Analysis - Title says it all
691. Managing Game States In C++ - Simple article presenting a design for how state management could be done in games, including state switching
692. Pwning Home Router - Hacking into a router
693. Concurrency In Modern Programming Languages - Implementing a web server in various programming languages
694. Async Rust Book - Async programming in rust, also shows how to implement a web server
695. Gently Down The Stream - Animated introduction to Kafka, for kids
696. Verilog, Formal Verification And Verilator Beginner's Tutorial - Learning verilog, combined with formal verification
697. Types And Programming Languages - Comprehensive intro to type systems
698. Differential Equations - Notes from a course of differential equations, useful to learn to solve diff eqs
699. Advanced Global Illumination - In-depth intro to the maths behind rendering
700. Fundamental Of Computer Graphics - A nice intro to CG in general
701. Ray Tracing From The Ground Up - Learn the theory for ray tracing
702. Reinforcement Learning: Theory And Algorithms - Book on reinforcement learning
703. Syntax Error Recovery In Parsing Expression Grammars - Technique used by cpp-peglib
704. A Trip Through The Graphics Pipeline (2011) - Seeing how the graphics pipeline works
705. What Every Programmer Should Know About SSDs - Taking advantage of the way SSDs work
706. Visual 6502 - Transistor-level simulation of the 6502
707. URLs: It's Complicated... - Some gotchas of URLs
708. Writing An Interpreter From Scratch - In Scala 3, could be useful for learning a bit of scala
709. Introduction To Grammars And Parsing Techniques - Gentle intro to PEG 'jargon'
710. Functors And Monads For People Who Have Read Too Many Tutorials - Much easier to understand alll this stuff now
711. Proper Seeding For `<random>` In C++ - Title says it all
712. Alta Via Del Sale - Breathtaking road from the Alps to the sea
713. Periodic Table - Easily searchable with lots of options
714. Let's Code A TCP/IP Stack - Blog series about writing a TCP/IP stack
715. Efficient Gaussian Blur With Linear Sampling - Techniques for Gaussian Blur
716. Achieving Fast Blurs - Title says it all
717. To paraphrase Winston Churchill... - Funny comment...
718. Hardware Memory Models - Learning about store orders
719. Any Encoding Ever - An easy to use library for dealing with encodings for C++
720. Write A Time-Series Dabatase From Scratch - Should be useful to learn about database internals in general
721. WebAssembly Series - Lots of resources on WebAssembly
722. Dynamic Linking Best Practices - Nice intro to dynamic linking
723. How SHA-256 Works - Step by step tutorial
724. SystemVerilog Tutorial - Title says it all
725. Learn Assembly By Writing Entirely Too Many Brainf*ck Interpreters - Learn assembly by writing a brainf*ck interpreter
726. Software Optimization Resources - Optimization tutorials
727. Mastering STM32 - Learning embedded dev
728. Ray Tracing From The Ground Up - Online PDF
729. Monadic Parsing In C++ - Inspired by (obviously) 'Monadic parsing in haskell'
730. What Is The Axiom Of Choice? - Title says it all
731. IoT For Beginners - From microsoft
732. Hosting SQLite Databases On Github Pages - How to make use of read only databases in JS, also useful to look at this blog's pandoc file
733. 5000x Faster CRDTs: An Adventure In Optimization - Deep dive into working with CRDTs, very interesting read
734. Muntii Baiului - Muntii Garbova, Carpatii de Curbura
735. Allocator Builder - Implementation for Andrei Alexandrescu's talk 'std::allocator'
736. Chronofold: A Data Structure For Versioned Text - Using CRDTs for collaborative text editing
737. PLT And GOT - The Key To Code Sharing And Dynamic Libraries - Learning more about dynamic libraries
738. We Make `std::shared_mutex` 10x Faster - Nice dive into memory reordering and various optimizations that can be done in general
739. Nullprogram Blog - Lots of interesting stuff
740. Fast And Economical UTF-8 Decoder - Using FSMs to implement a very simple and efficient UTF-8 decoder
741. Why Aren't There C Conferences? - Includes a good list of 'to-watch' videos from CppCon
742. PHP: A Fractal Of Bad Design - Fun to read rant about PHP
743. You Might Not Need Machine Learning - Implementing simple AI for self-driving cars in racing games
744. The Unreasonable Effect Of Quasirandom Sequences - Learn some statistics...
745. How To Generate Uniformly Random Points On N-Spheres And N-Balls - Useful for ray tracing
746. Learn APL - Title says it all
747. Memory-Mapped Devices As Objects - Good video on embedded, CppCon
748. Scanning QR Codes - Scanning QR from scratch
749. How Watches Work: What Is An Automatic Watch And What Different Types Of Winding Weights Are There? - Really interesting read on automatic watches
750. What Inline Means In C And C++ - Title says it all
751. What Makes Dependent Type Theory More Suitable Than Set Theory For Proof Assistants - In-depth overview of proof-assistants
752. Kind - Proof-based programming language that's easier to use
753. High Performance Browser Networking - Explaining various networking concepts
754. Computer Networking Introduction: Ethernet And IP - Intro to networking concepts
755. Pasul Gutai - Creasta Cocosului - Pasul Neteda - Traseu prin Baia Mare
756. Modern SQL - Good resource for learning SQL
757. I Wrote A Linker Everyone Can Understand - Learning more about linkers
758. Writing An Assembler - Also has a post about writing a dissasembler
759. Understanding Pac-Man Ghost Behavior - How pac-man works
760. How To Teach Programming (And Other Things)? - How to actually teach
761. Widelands - RTS Game, open-source, should play
762. Naval Architecture - How Ships Work
763. CS Papers That Should Be Read - Mostly about distributed systems
764. OnParers - Intro to parsing methods
765. Old (But Interesting) GCC Bug - Should look into it
766. Eliminating Run-Time Errors With Agda - Intro to Agda
767. The Maths Of 2048 - Play with Markov Decision Processes
768. Linux In A Pixel Shader - Crazy...
769. Making An OS - Youtube Playlist
770. The Little Book Of Semaphores - Learning about semaphores
771. On Recursive Mutexes - Why recursive mutexes are probably not what you want
772. The Purpose Of `memory_order_consume` In C++11 - What is `memory_order_consume` used for?
773. All About The Global Offset Table - Learning more about GOT
774. How DNS Works - Illustrated tutorial on DNS, very fun to read
775. MIT Artificial Intelligence Course - To _properly_ learn AI
776. Theory Of Relational Databases - Properly learning database theory, old resource but still relevant
777. Foundations Of Databases - Another excellent resource on database theory
778. Database Theory - Staying up to date with latest research in the DB space
779. Readings In Database Systems - Techniques for working with databases at scale
780. An Introduction To Database Systems - Deep dive into databases, teaches a lot of concepts
781. Rhai - Scripting language for Rust
782. Rust's Module System Explained - Understanding Rust's modules
783. Cargo-ASM - Inspecting ASM/LLVM-IR of Rust codebases
784. Crust Of Rust: Async/Await - Learning about async programming in Rust
785. PostgreSQL Subtransactions Considered Harmful - Deep dive into postgre and why subtransactions are probably something you don't want
786. Operating Systems: Three Easy Pieces - Good, free alternative to 'The Dinosaur Book'
787. Writing An OS In Rust - Goes into a lot of topic, nice read
788. Writing A File System From Scratch In Rust - Overview of what's needed to implement an FS
789. Async/Await In Rust - _Actually_ implementing an async runtime in Rust, from scratch
790. Forward And Reverse Proxies Explained - More on networking
791. Helio - Libre music composition
792. Music Theory For The 21st-Century Classroom - Learning music theory
793. `std::shared_ptr` Aliasing Constructor - How to share ownership with `std::shared_ptr`
794. So You Want To Study Philosophy... - Resources for learning philosophy
795. The Anatomy Of A Large-Scale Hypertextual Web Search Engine - Bit of history about how google search engine works
796. Meta Assembly - Interesting project that implements a 'portable' assembly
797. Nano-Coroutines To The Rescue! - Scaling up to billions of coroutines in C++
798. Understanding GPU Caches - Dive into the hardware of GPUs
799. Video Compression Basics - Title says it all
800. Frei-Chen Edge Detector - Implementing edge detection
801. Understanding And Implementing The Viola-Jones Image Classification Algorithm - Title says it all
802. GPU Architecture Types Explained - Difference between tile-based rendering and immediate-mode rendering
803. Reconstructing Pong On FPGA - Excellent article
804. Implementing Pong At The Circuit Level - Nice intro to hardware design
805. Buddy Memory Allocators - Using binary trees for memory allocators
806. Recycling Lithium-Ion Batteries From Electric Vehicles - Methods for recycling batteries
807. Implementing Raft - Series implementing Raft consensus algorithm in Go
808. Nandgame - Implementing A Computer From Scratch
809. A Gentle Introduction To Graph Neural Networks - Worth mentioning that the design of the website has a really nice citation style
810. Articole De La Mihai Budiu - Articole de calitate românești
811. Programming With Proofs - Gentle intro to Agda
812. Car Physics For Games - How to implement car physics for games
813. Fun Fact About IPv6 - There's enough addresses to assign around 1M addresses to every bacteria cell on the planet
814. Creating A Low-Latency Calling Network - How to avoid Asterisk/FreeSwitch, talks about different DNS responses based on region
815. The Signal Protocol - Protocol for End-To-End encryption, used in many more places than I expected
816. Double Ratchet Algorithm - Used in the Signal Protocol
817. Data-Oriented Design Book - Why DOD?
818. Casual Effects - Test cases for ray-tracers
819. The Rust Performance Book - Profiling, inlining, hashing, logging/debugging, parallelism covered
820. Cargo-Flamegraph - Profiling visualisation for rust
821. Higher Performance Traversal And Construction Of Tree-Based Ray-Tracing Acceleration Data Structures - Building an efficient BVH
822. 2D Barcode Image Decoding - Decoding QRs
823. Self-Referential Logic Via Self-Referential Circuits - Interesting read on circuits
824. What Is A Photon? - Title says it all
825. Logarithms And Exponentials Of Functions - Answers for `g(g(x)) = f(x)`
826. 2-adic Logarighms And Fast Exponentiation - Title says it all
827. What Is Cryptography? - A high-level overview of crypto
828. Munții Rodnei - Carpații Orientali
829. Ray-Casting In 2D Game Engines - Nice, easy-to-understand explanation for ray-casting
830. Resource-Efficient Thread Pools With Zig - Implementing a work-stealing thread pool without allocations
831. A Concurrency Cost Hierarchy - Benchmarking various concurrency 'things', very nice post
832. Elevenn Proofs Of The Gaussian Integral - Title says it all
833. Performance Matters - Blog about performance/concurrency, lots of interesting posts
834. Beating Up On Qsort - Contains info on why C++'s `std::sort` is faster than `qsort`
835. Performance Speed Limits - How much certain stuff can be optimized
836. Math Pages - Incredibly good website for maths and physics
837. nLab - Really nice wiki for stuff related to maths/physics/philosophy
838. Java Version History - Title says it all
839. A Generic Framework For Physical Light Transport - Presented at SIGGRAPH 2021
840. Computing Minimal Surfaces With Differential Forms - Also presented at SIGGRAPH 2021
841. Proof Theory Blog - Various proofs, logic-related
842. Arxiv-Vanity - Viewing arxiv papers directly in the browser
843. A Practical Guide To Radial Basis Functions - Title says it all
844. A Fully-Parallel Pipeline For High-Quality Rendering Of Vector Graphics Illustrations - The preliminaries section is very useful
845. Performance Without The Event Loop - How goroutines are so efficient
846. Computing Discrete Logarithms - Presents various algorithms for computing discrete logarithms
847. 1024 Cores - Blog with a lot of useful info related to concurrency/paralellism
848. Matrix Computations - Everything Matrices
849. A Tour Of Deep Learning With C++ - A nice intro to deep learning in general
850. A Brief, Incomplete, Mostly Wrong History Of Programming Languages - Hilarious...
851. Shooting Yourself In The Foot In Varioius Programming Languages... - Also hilarious...
852. Machinery's Handbook - Mechanical engineering book, great reference
853. Pipe Fitter's Blue Book - Great resource on pipe fitting
854. What Is A Monad And Who Needs Haskell Anyway? - Very simple to understand explanation of monads
855. When McDonalds Came To Denmark - Why McDonalds employees are paid 22$/hr in Denmanrk (unions)
856. Async Stack Traces In Folly: Synchronous And Asynchronous Stack Traces - How to get stack traces with coroutines
857. The Implementation Of `epoll` - Deep dive into how `epoll` works in linux
858. On Error Messages With Parser Generators - Showing various limitations/issues with some parser generators
859. Why C++20 Is The Awesomest Language For Network Programming - Illustrating the use of boost.asio with C++ coroutines
860. Writing Embedded Firmware In Rust - How to use Rust on STM32
861. Advanced Error Handling In OCaml - Title says it all
862. Calling Bullshit - How to identify bullshit
863. How To Deconstruct Almost Anything - 'Scientists are paid for being clever, not for being right'
864. Self-Parking Car In 500 Lines Of Code - Using genetic algorithms to implement a self-parking car
865. Tuplet - An efficient implementation of `std::tuple`
866. The New Pass Manager In LLVM - Describes at a high-level how the new pass manager works in LLVM and how it interacts with the previous one(s)
867. Bracket Pair Colorization 10.000x Faster! - How VSCode uses a modified AST and (2,3)-Trees to implement bracket colorization extremely fast
868. The Art Of Linear Algebra - Illustrated explanations of various concepts in linear algebra
869. How Do CRCs Work? - Explaining cyclic-redundancy-checkers
870. Formal Verification Of A Distributed Dynamic Reconfiguration Protocol - The replication protocol for MongoDB, derived from Raft, formalized in TLA+
871. Gentle Introduction To GPU Inner Workings - Easy to understand high-level overview of GPU inner workings
872. The Lord Of The `io_uring` - Understanding and practising `io_uring`
873. Reverse-Engineering An Unusual IBM Modem Board From 1965 - Great tutorial on reverse-engineering
874. PL Resources - _Lots_ of excellent resources on programming languages(theory w/ tutorials)
875. Why We Spent The Last Month Eliminating PostgreSQL Subtransactions - Deep dive into why subtransactions are considered harmful
876. Cunningham's Law - 'The best way to get the right answer on the Internet is not to ask a question; it's to post the wrong answer.'
877. Homotopy Type Theory: A synthetic Approach To Higher Equalities - Includes a really nice intro to type theory in general
878. Turing-Complete - Game where you build a CPU and assembly language from circuits
879. Hierarchical Rasterization Of Curved Primitives For Vector Graphics Rendering On The GPU - Introducing `CPatch`, a new primitive for rendering vector graphics
880. An Outlook On Lithium-Ion Battery Technology - Useful not only as a paper but also for finding new papers regarding battery tech(search by citations)
881. Database Normalization Poster - Cheatsheet for understanding normalization levels
882. Simplest Example Of Simpson's Paradox - Example with a disease and magic pills for treatment
883. Understanding How Facebook Disappeared From The Internet - Understanding More About BGP And DNS
884. Betteridge's Law Of Headlines - 'Any headline that ends in a question mark can be answered by the word no.'
885. Teach Me PCB - PCB course(s)
886. Analysis Of Boolean Functions - Title says it all
887. How To Achieve Proper Grounding - Another PCB resource
888. Haskell For Imperative Programmers - Excellent resource on haskell
889. Tools To Explore BGP - Learning more about BGP
890. Interactive TLA+ - Analyzing various tools for TLA+
891. Bootloader Basics - Implementing bootloaders in Rust
892. Write Your Own Virtual Machine - Intro to writing VMs
893. An Introduction To Mathematical Logic - Title says it all
894. A Fresh Look At Generalized Sampling - Proper learning of sampling theory
895. Guide To Modern OpenGL Functions - Modern == OpenGL 4.0+
896. Computer Networking : Principles, Protocols And Practice - Book on networking in general
897. Implementing TCP In Rust - Great tutorial on networking (and Rust)
898. Ocean Simulation Method - Method for simulating an ocean fastly and accurately
899. Yoctolisp - Lisp in a weekend
900. Stretch - High-performance flexbox implementation in Rust, successor to Yoga
901. LRU Clock-Cache - Fast cache implementation in C++
902. Measuring `std::unordered_map` Badness - How to improve `std::unordered_map` with a good hash funciton
903. Programming PIC32 Controller With Rust - How to use Rust on a more 'exotic' platform
904. How Climate Scenarios Lost Touch With Reality - How the situation with climate change _really_ is
905. Algorithmica - Book on performance analysis(alternative link: 'https://github.com/algorithmica-org/algorithmica')
906. Graphics Compendium - A few lessons on graphics programming in general
907. Creating A Volumetric Ray Marcher - Nice smoke effects with ray marching
908. How Python Integers Work - Python integers behind the scenes
909. Network Programming With Go - Practical Go book on networking
910. Neural Networks From Scratch - Interactive guide to neural networks
911. Calculus On Computational Graphs: Backpropagation - Learning more about backpropagation
912. Parsing JSON Is A Minefield - Interesting notes about the JSON format
913. Weeks Of Debugging Can Save You Hours Of TLA+ - Formalizing a concurrent queue with TLA+
914. Electrical Engineering And Computer Science - _Lots_ of MIT courses on CS
915. Algebraic Effects For The Rest Of Us - Very easy to understand explanation of algebraic effects
916. Multi-Level Cache That Does Up To A Billion Lookups Per Second - In C++
917. The Networking TS Is Baked, P2300 Sender/Receiver Is Not - A comparison between the ASIO and the sender/receiver models
918. Crash Course In BRDF Implementation - Learning More About BRDFs
919. ASIO And The Power Of Completion Tokens - Using ASIO with coroutines
920. Practice Problems For Hardware Engineers - Learning about hardware design
921. Tiny ELFs: Revisited - Learning more about the ELF format
922. Theory Of Computation - Great course from MIT
923. Liquid Neural Networks - Interesting approach to neural nets
924. Rasterization Of Parametric Curves Using Tesselation Shaders - Focused on rendering the curves themselves, not shapes defined by them
925. Turing Complete - A game where you build a CPU from scratch
926. C Preprocessor Tips, Tricks And Idioms - Learning hacks with the macro preprocessor
927. Prevent An Optimizing Compiler From Removing Or Reordering You Code - How to implement `DoNotOptimize`
928. What To Learn - Learn a few tricks...
929. Awesome-Loginless - List of online services that don't need logging in
930. A Graduate Course In Applied Cryptography - Thorough course on cyrptography
931. How A Simple Linux Kernel Memory Corruption Bug Can Lead To Complete System Compromise - An incredibly nice walkthrough
932. Schemes In Lean - Learning lean
933. Stacks Project - Reference on algebraic geometry
934. Encyclopedia Of Maths - What the title says...
935. Planet Math - Accessible mathematical knowledge
936. Proof Wiki - Proof reference
937. Awesome-Math - Lots of resources on maths
938. An iOS Zero-Click Radio Proximity Exploit Odyssey - Incredible post on security/reverse-engineering
939. Dubious URL In The Golang Standard Library - Funny issue
940. Verilog Simulation With Verilator And SDL - Nice way to learn verilog
941. STX B+Tree - A production-ready implementation of a B+Tree in C++
942. The Push For GATs Stabilization - Includes a quick intro to GATs
943. MollyRocket - Includes videos from the author of refterm explaining various concepts
944. A Pragmatic Introduction To Signal Processing - Illustrated book
945. The Scientist & Engineer's Guide To Digital Signal Processing - _The_ book on DSP
946. CPP Mappings - How some atomic operations map to various CPU instructions
947. Advent Of TLA+ - AoC challenges formalized in TLA+, can be a great resource to learn TLA+
948. An Introduction To Probabilistic Programming - Title says it all
949. The Design And Implementation Of Probabilistic Programming Languages - Title says it all
950. Warren's Abstract Machine: Tutorial Reconstruction - Deeper dive into prolog
951. Writing A Storage Engine In Rust: Writing A Persistent B-Tree - How to implement a B-Tree in Rust
952. Concurrent Programming With Effect Handlers - Seeing algebraic effects in action
953. Parsing Protobuf At 2+GB/s: How I Learned To Love Tail Calls In C - Parsing can be efficient using recursion
954. Moves In Returns - Should we `std::move` when we return?
955. Friendship Paradox - People have fewer friends than their friends have, on average
956. Borrowing Trouble: The Difficulties Of A C++ Borrow-Checker - Why it's so difficult to achieve rust-levels of safety in C++
957. CRDT Tech - Learning more about CRDTs
958. CRDTs: Everything You Need To Know - Lots of resources on CRDTs
959. Self-Fulfilling Prophecy - A prediction coming true simply because the person believes or anticipates it will
960. A Byte Of Coding - Curated material from hacker news/lobsters/reddit/etc.
961. How To Exploit A Double-Free - Bug that doesn't exist on x86 but exists on ARM
962. Mathematichs For Computer Science - Comprehensive guide to maths, includes stuff related to probability and statistics, a bit of logic
963. Fast-Paced Multiplayer: Client-Server Game - Learn more about game networking
964. All About Thread-Local Storage - Deep dive into thread-local storage
965. Optimizing File Access Via Ordering And Caching - Strategy used by the game '0AD'
966. VNC Data Compression Algorithm - Directly from the RFC
967. Ryu Algorithm for Float To String Conversion - Fastest (yet) algorithm for float to string conversion
968. Functional Description Of Tex Formula Layout - How Tex works behind the scenes
969. Programming Trick Questions - A few nice questions everybody should know the answer to!
970. B-Tree - The data structure behind databases/file systems
971. What Every Programmer Should Know About Memory - Classic
972. Full Stack Course University Of Helsinki - Modern proper course on full-stack dev
973. Interactive Guide To Buffer Overflow Exploitation - Nice guide to reverse-engineering
974. An Efficient Unification Algorithm - Learn more about unification
975. Nand2Tetris: Computers From Scratch - Excellent guide to building computers
976. Architecture Of Open Source Applications - Great way to learn more about some open source projects' internals
977. MQTT: IoT Protocol - _The_ IoT protocol
978. Meyers Diff Algorithm - Very useful diffing algorithm
979. Monte Carlo Method - Approximation in style
980. Pattern-Defeating Quicksort - A special quicksort
981. Lomuto's Comeback - An interesting sorting algorithm
982. Project Based Learning - Get project ideas from here
983. A Graphical Introduction To Lattices - Title says it all
984. All About Circuits - Excellent resource on circuits
985. Computer Science Of TeX and LaTeX - Learn more about the internals of (La)Tex
986. Systems Design for Advanced Beginners - Gentle intro to systems theory
987. Creating A Circular Buffer In C And C++ - Simple circular buffer design
988. JPEG XL Image Format - An interesting image format
989. Baeldung: Spring Projects - Includes good documentation on various java things
990. Concurrency Freaks - Great blog on various concurrency-related stuff
991. Interviews School - Preparing for interviews
992. Problem Solving - How to approach an unkown problem
993. Exploring How Computers Work - A very nice tutorial on how computers work
994. Ctrie - Concurrent Trie
995. List of Free CS Books - Some excellent books here
996. Splitting A Rectangle In Many - Algorithms behind conference apps
997. Distributed Systems For Fun And Profit - Great book on distributed systems
998. ULID Spec - UUID alternative: lexicographically sortable, case insensitive, URL safe
999. XOR Filters - Faster and Smaller Than Bloom Filters
1000. So You Want To Roll Your Own Crypto? - Excellent crypto tutorial/blog
1001. Shamir's Secret Sharing: A Numeric Example Walkthrough - Excellent walkthrough through this algorithms
1002. Basic Intro To Elliptic Curve Cryptography - Learning ECC
1003. Making Music With Mathematics - From the legendary Inigo Quilez
1005. Learning Synths - Excellent resource
1006. Digital Sound Processing Tutorial For The Braindead - Title says it all
1007. Sel4 - Formally Verified Kernel
1008. Genode - Non-POSIX OS Framework
1009. Learn Emulator Development - Nice discussion
1010. OSDev - Great wiki for os development
1011. How Are UNIX Pipes Implemented? - Learning more about pipes
1012. Implementing An OS In Rust University Course - Fun way to learn Rust
1013. Writing A RISC-V Emulator from Scratch - Fun way to learn more about Rust and RISC-V
1014. How To Write A CHIP-8 Emulator - Simple and to the point
1015. Writing A NES Emulator - Title says it all
1016. Hardware And Software Support For Virtualization - Learning more about virtualization
1017. HyperDrive: Peer to Peer Filesystem - Interesting file system
1018. Adventures In RISC-V - Learning more about RISC-V
1019. How To Write A Toy JVM - Title says it all
1020. Containers The Hard Way: Gocker - Writing a container runtim in go
1021. Writing A Linux Debugger - Tutorial on writing a debugger
1022. RaspberryPiOS - Learn OS Dev with Linux Kernel and RaspberryPi
1023. Curs Sisteme De Operare - Introducere ușoară
1024. Simple Filesystem Implementation - Great resource on implementing a file system
1025. Generating Aligned Memory - Simple to understand explanation of how to generate aligned memory
1026. Writing A Memory Allocator - Good resource on how to write a memory allocator
1027. A Fast And Thread Safe Memory Allocator For Qt - Interesting read about Qt's memory allocation strategy
1028. Writing A RISC-V OS in Rust - Old version
1029. Writing a RISC-V OS in Rust - New
1030. PrettyOS - Preemptive Hard Real-Time Kernel For Embedded Devices - Title says it all
1031. The Microarchitecture Of Intel, AMD And VIA CPUs - Title says it all
1032. Operating System Development Series - Excellent resource on OS-Dev
1033. Operating Systems: From 0 To 1 - Step by step tutorial on writin an OS
1034. Isolating GPU Access In It's Own Process - Great read on security
1035. Everyone Should Learn To Read Assembly - Interview with Matt Godbolt
1036. RISC-V Assembly Language - Reads like lecture notes on RISC-V
1037. An Introduction To ZFS - A Place to Start
1038. The Very Basics Of A Terminal Emulator - How to write a terminal emulator
1039. How To Make An OS - From poncho
1040. Towards A Synthetic Benchmark To Assess VM Startup, Warmup And Cold-Code Performance - How to benchmark properly
1041. OSQuery - SQL as binutils
1042. Inferno OS - Kind of Successor of Plan9, probably useful as a reference
1043. Roll Your Own Unix-Clone OS - Write a unix clone
1044. Bran's Kernel Development Tutorial - Kernels 101
1045. Use `mmap` With Care - Pitfalls of `mmap`
1046. Emulating A CPU In C++ - 6502
1047. Array Based Queueing Locks - Lock algorithm that ensures that threads spin on unique memory locations
1048. Tutorial: Write A Shell in C - DIY shell
1049. Designing A RISC-V CPU - Learning Hardware Design as a Software Engineer with nmigen
1050. Learn The Basics Of FPGA Design - Title says it all
1051. Tomasulo Algorithm - Algorithm For Out of Order Execution
1052. How To Read Assembly Language - Title says it all
1053. Programming In Assembly Language Tutorial For AMD64/Intel 64 - Title says it all
1054. TIS-100: Game - You have to program in some kind of assembly
1055. Optimising Pointer Substraction With 2-adic Integers - Great post on 2-adic integers
1056. Clock Gating - Learn more about hardware design
1057. Towards An Automatic Proof Of Lamport's Paxos - Automatically proving the safety of paxos
1058. A Tutorial On The Principles Of Fault Tolerance - How to 'fault tolerate'
1059. Learn You An Agda - Agda tutorial
1060. Exploring PL/PGSQL: Implementing A Forth-like Interpreter - Running forth inside PL/PgSQL
1061. Study And Comparison Of Mesh And Tree-Based Multicast Routing Protocols - Learning more about routing protocols
1062. How Do Routers Work, Really? - Learning more about routing
1063. How HTTPS Works - Really nice tutorial on HTTPS, very entertaining
1064. Network Programming In Age Of Empires And Beyond - How networking in AOE works
1065. Networking In C++ With Boost ASIO - Learn ASIO
1066. Beej's Guide To Networking - Classic tutorial on sockets
1067. The Actual OSI Model - Real mapping of OSI in real-life
1068. Awesome-CRDT - Lots of links regarding CRDTs
1069. Automerge: Library for Building Collaborative Apps - Useful to look at its source
1070. CRDT: Conflict Free Replicated Data Type - What CRDT means...
1071. A Multi-User Selective Undo/Redo Approach For Collaborative CAD Systems - Undo/Redo in collaboration
1072. CRDTs: The Hard Parts - Deeper dive into CRDTs
1073. How Yjs Works From the Inside Out - Deep dive into Yjs and CRDTs
1074. CRDTs Explained - Title says it all
1075. CRDTs For Non Academics - Great intro to CRDTs
1076. Why Vector Clocks are Easy - Learning more about distributed systems
1077. Go-ds-crdt: Merkle CRDTs - Interesting data structure
1078. Data Laced With History: Casual Trees And Operational CRDTs - Deep dive into CRDTs with actual practical examples
1079. RRB-Tree For Text Editors - How Relaxed-Radix-Balanced-Trees work
1080. Data Structure For Text Style - Implementing rich text
1081. Data Structures for Text Editors: Crowley - Analyzing piece tables and gap buffers, misses ropes
1082. Efficient Data Structure For A Hex Editor - Implement an editor with a B-Tree
1083. A Brief Glance At How Various Text Editors Manage Their Textual Data - What data structures various text editors use
1084. Breaking Paragraphs Into Lines - Knuth's paper on line breaking, excellent resource
1085. Rope Science: Xi Editor - Deep dive into ropes
1086. An Undo Framework For P2P Collaborative Editing - Implementing undo for a collaborative editor
1087. LSEQ: Adaptive Structure For Sequences In Distributed Collaborative Editing - How to implement collaboration
1088. Abi Collab - How Abi Word implements collaboration
1089. Type Systems for Programming Languages - Learning more about type systems
1090. Open Source Collaborative Text Editors - List of text editors
1091. Differential Synchronization - Another method to keep documents in sync
1092. Operational Transformation - Alternative to CRDTs
1093. Understanding And Applying Operational Transforms - More on operational transfoms
1094. SubEthaEdit - Online text editor
1095. Libinfinity: Collaborative Editing - Framework for building collaborative text editors
1096. Diff-Match-Patch - Yet another method for keeping documents in sync across a network
1097. Build Your Own Text Editor - Great series on writing a text editor
1098. Build Your Own Text Editor in Rust - Another great resource on building a text editor
1099. Chrome University - Learning more about chrome
1100. LexBor HTML 'Renderer' - Could be useful as a reference
1101. Flex Layout Algorithm - The algorithm's inner workings
1102. Grid Layout Algorithm - The algorithm's inner workings
1103. Pathfinder: GPU Rasterizer For Fonts And Vector Graphics - Useful as a reference
1104. How To Manage The HTML DOM - Manipulating the DOM
1105. Overconstrained.io: Cassowary Algorithm - Algorithm for laying out things
1106. Jargon - Browser jargon
1107. Gecko Overview - Overview of the 'back-end' of firefox
1108. Dawn: Chromium's WebGPU Implementation - Title says it all
1109. Layout Engines For Web Developers - How layout engines work
1110. How Browsers Work - Excellent overview of browser internals
1111. Web Browser Engineering - Excellent resource on browser internals
1112. Firefox Flex Layout Implementation - Implementation of flex in firefox
1113. Firefox Grid Layout Implementation - Implementation of grid in firefox
1114. Incomplete List Of Mistakes In The Design Of CSS - Nice read regarding CSS
1115. Parallel Web Layout Algorithms - Also for CSS selector matching and font rendering
1116. High-Throughput Fizz-Buzz - At over 50+ GB/s, using assembly
1117. Using Hugo and Gitlab Pages to Make a Website - Title says it all
1118. Drag And Drop With Vanilla JS - Title says it all
1119. Comments With Github Issues - Dynamic comments with static sites
1120. CSS For Internationalization - i18n with CSS
1121. A Single Div - Generating images with CSS styling applied to HTML elements
1122. Customizable SVG Icons - Nice collection of icons
1123. Free Vector Animations And Illustrations - Another collection of icons
1124. The Flexbox Holy Albatross - More about flexbox
1125. Svelte Tutorial: The Net Ninja - Learn svelte
1126. Full-Bleed Layout Using CSS Grid - Nice little layout
1127. How to Build An Ecommerce Site With Strapi, Vue.js and Flutterwave - Learning to use strapi
1128. Github Issues As A Hugo Frontend - Very interesting way of generating blog content remotely
1129. Build An Instagram Clone With Svelte And Strapi - Great way to learn svelte
1130. Build An API In Rust With JWT Auth And Actix - Real-World use case for Actix-web
1131. Bytemd: Hackable Markdown Editor In Svelte - Modern text editor in svelte
1132. PSX Party: PSX Games Online With WebRTC - Online p2p games
1133. Practical Color Theory For People Who Code - How to choose colors for a website so it looks good and consistent
1134. Color In UI Design: A Practical Framework - Good color design
1135. Writing A Databse From Scratch In Go - Great tutorial on learning more about go and databases
1136. Crux Database Using Datalog - Prolog for databases is... nice
1137. How Doeas A Relational Database Work - Excellent resource on databases
1138. Datalog: SQL Alternative - Using prolog to query databases
1139. Relational Algebra - The backbone of relational databases
1140. How `io_uring` and eBPF Will Revolutionize Programming In Linux - How `io_uring` and eBPF help
1141. Let's Bulid A Database - SQLite Clone from Scratch in C
1142. SQL Interview Questions - Common SQL knowledge
1143. How Does SQLite Work? - Looking at the internals of SQLite
1144. The Internals Of PostgreSQL - Peeking in the PgSQL source code
1145. PostgreSQL Internals - From the official documentation
1146. DBeaver - Universal Interface To Databases
1147. SQL X To Y - one-to-one, many-to-many etc.
1148. Postgres Observability - Structured search around the postgres' source code
1149. Implementation Of A B-Tree Database Class - Implementing a B-Tree
1150. Implementing A Key-Value Store - Title says it all
1151. Introduction To Window Functions In SQL - What are window functions
1152. ARIES: Algorithms For Recovery And Isolation Exploiting Semantics - Useful for atomicity and durability implementation
1153. Shadow Paging - Also useful for atomicity and durability implementation
1154. Implement Key-Value Store By B-Tree - Title says it all
1155. Dolt: Git For Data - Interesting concept
1156. Linear Algebra Book - Great resource on linear algebra
1157. All In One Math Cheatsheet - Excellent reference on various formulas
1158. Applications Of Linear Algebra - Practical linear algebra
1159. Fast Fourier Transform: The Most Ingenious Algorithm Ever? - Incredibly nice visualization of the FFT
1160. From Set Theory To Type Theory - Learning more about type theory
1161. Homotopy Type Theory: Profunctors - Also includes some views on set theory
1162. Homotopy Type Theory Book - _The_ book
1163. Homotopy Type Theory For Dummies - Nice intro to HoTT
1164. Physics, Topology, Logic And Computation: A Rosetta Stone - Lambda calculus, logic,
1165. Structure And Interpretation Of Classical Mechanics - Great book
1166. Lewin's Circuit Paradox - Interesting read
1167. Div, Grad, Curl Are Dead - Excellent maths book
1168. On Teaching Mathematics - How to teach maths
1169. Axiom Of Choice Is Wrong - Amazing article
1170. Rality As A Vector In Hilbert Space - Fascinating read
1171. The Derivative Isn't What You Think It Is - Greater insight into derivatives
1172. Fastai: Neural Nets - Courses on neural nets
1173. Lossless Image Compression Through Super Resolution - Title says it all
1174. Learning To See in the Dark - Amazing image processing project
1175. Andrew Ng: Machine Learning - Has good courses on ML
1176. Adversarial Latent AutoEncoders - Autoencoders
1177. Markov Chain Text Generation - Generating random text
1178. Neural Net In C++ - Step by step implementation
1179. Deep Learning From Scratch - Deep learning tutorial
1180. The Mathematics Of Neural Networks - Title says it all
1181. Let's Build A Full-Text Search Engine - Learning more about search engines
1182. Machine Learning From Scratch: Derivations In Concept And Code - Learning ML
1183. Machine Learning 101: 2 Years Of Headbanging So You Don't Have To - ML overview
1184. Building Full Text Search Engine In 150 Lines Of Python - Title says it all
1185. Learn To Fly: Let's Simulate Evolution In Rust! - Using neural nets and genetic algorithms
1186. Neural Radiance Fields - Interesting concept
1187. Write Yourself A Git - Title says it all
1188. Isomorphic-git - Git in js
1189. Pijul - Patch theory
1190. Visualising Git Concepts With D3 - Easy git tutorial
1191. Some Of Git Internals - Learn some more about git
1192. Git Cheat Sheet - Git commands
1193. Learning Music - Title says it all
1194. OnlyOffice - Alternative to MS Office
1195. Build-Your-Own-X - Lots of project ideas
1196. RMarkDown Basics - Title says it all
1197. RMarkDown Basics: More - More about RMarkdown
1198. Arrow Operator in Apple Docs - `-->` spotted in the wild
1199. Mapping Resposibly - Cartography tutorial
1200. Javidx9 - Lots of interesting videos
1201. 3blue1brown - Excellent maths videos
1202. Ben Eater - Lots of useful videos about CS, mostly about hardware/embedded
1203. Comparison Of Voting Schemes Security - Title says it all
1204. ContextFree - Lots of interesting videos on programming lanugages
1205. Why Open Source Matters For Government And Civic Tech And How To Support It - Interesting read
1206. Talkyard: Forum Software Combining Best Of SO, Discourse, Slack, HN/Reddit, Disqus - Interesting forum design
1207. Jami: GNU Open Source End-To-End Encrypted Alternative To Zoom/Jitsi - Nice tool
1208. Matrix: Decentralized Communication - Open protocol for p2p communication
1209. Hilarious NixOS Github Issue - Just funny
1210. WasyPrint: Nice Document Formatter - Could be an alternative to Latex
1211. John Conway Memorial - Insight into Conway's life
1212. John Conway Memorial 2 - Continuation of the previous link
1213. ArduBee: Open Source Drone - Title says it all
1214. IOS on QEMU - Good to know
1215. Software Engineer Going Blind - Learning more about accesibility
1216. OpenHAB: Open Source Home Automation - DIY
1217. How The Economic Machine Works - Excellent video on economy
1218. Patch Workflow With Mutt - Mutt power use, probably useful to read if ever implementing an email client(ar a forum)
1219. Engineering Code Quality In Firefox - Interesting read on firefox devops
1220. Home Assistant: Open Source Home Automation - DIY
1221. OpenMediaVault: Open Source NAS - DIY
1222. Design Of Everyday Things - Great book on design of various things, like door handles
1223. Mediasoup: WebRTC Video Conferencing - Nice tool
1224. PyInvoke - Alternative to make
1225. Warzone 2100: Open Source RTS Game - Could probably learn from this
1226. Ledger: CLI Accounting System - Good to know such a tool exists...
1227. Why Birds Can Fly Over Mount Everest - Very interesting read on birds
1228. Present: A Presentation Tool In The Terminal - Powerpoint in the terminal
1229. How To Be Helpful Online - Great tips for online 'mentors'
1230. When You Browse Instagram And Find Australia's Prime Minister Passport Number - Very entertaining read
1231. EtherCalc: Open Source Online Office Suite - Great alternative to MS Office
1232. SC-IM: Excel In The Terminal - Really interesting tool
1233. Mathematics For Programmers - Various tricks for programmers, really interesting
1234. Interesting Facts About 3435 - Interesting stuff about number theory
1235. SculptGL - Sculpting directly in the browser
1236. Windows XP in React - Recreation
1237. Windows 93 Online - Another recreation
1238. SVG Path Editor - Online SVG editor
1239. NonViolentCommunication - Polite disagreement
1240. WiRedPanda: Software For Logic Circuits In Qt - Really interesting tool
1241. I Grew Real Spider Silk Using Yeast - Incredibly interesting read
1242. ChezMoi: Managing Dotfiles Across Multiple Diverse Machines - Better dotfile managing
1243. Space-Search: All Satellites In Space - Visualizing all of them
1244. The Physics Of Baking Good Pizza - Great read
1245. Animated Engines - Illustrations Of How Various Engines Work
1246. ISO 3103: International Standard For Preparing A Tea - Correctly preparing a tea
1247. VSCode CodeTour - Guided walkthroughs of codebases
1248. How to Code a PasteBin Clone - Title says it all
1249. Build A URL Shortener In 15 Minutes - Title says it all
1250. How To Make Your Own Bittorrent Client - Title says it all
1251. How To Stream Audio From Your Phone To Your Laptop - Title says it all
1252. Comments For Static Websites Using Github Issues - Another way to have dynamic comments on a static site
1253. DIY Smart Doorbell With A Raspberry Pi - Really fun project
1254. Challenging Projects Every Programmer Should Try - Lots of nice ideas
1255. Snapdrop: AirDrop Equivalent Through A Web Browser Using WebRTC - Title says it all
1256. C++ Concurrency In Action - Practical Multithreading
1257. The Millionaire Fastlane - On economy
1258. Structure And Interpretation Of Computer Programs - Great CS book
1259. Other Minds: The Octopus, The Sea, And The Deep Origins Of Consciousness - Learning more about octopuses
1260. Test-Driven-Development At Oracle... - Guy telling a story about how it is to commit changes in the Oracle database, having millions of tests that need to run
1261. Some notes on ARIES - Somebody describing the benefits of ARIES for atomicity and durability implementation in a database
1262. Something About Pythoplankton - Discussion about phytoplankton
1263. Discussion About How Whales Are Beneficial To Phytoplankton - Whales eat krill which eat phytoplankton which eat whale poop
1264. Some Implementation Details Of Bloom Filters - Some redditor sharing his experience writing bloom filters and how they can be implemented efficiently
1265. Slug VS. Pathfinder - Comparison between slug and pathfinder internals
1266. An Opinion On ReactOS - Kernel Engineer at Microsoft Discussing About ReactOS
1267. Python Bomb - 16 Bytes of Python That Compile to 32 Terabytes of Bytecode
1268. Some Interesting Discussion On SDFs - and how even with no multi channel signed distance fields rounded corners can be partially avoided if we use the original glyph data as input instead of a rasterized glyph
1269. Porting Takua Renderer To ARM - Great article on porting a path tracer to ARM
1270. Understanding Fluid Simulation: Microscopic Perspective - Extremely nice animations
1271. Sudoku Solver With Prolog - Easy to understand tutorial, also includes a simple http server in prolog
1272. Chumsky - Parser combinators with great error messages, also has a nice error recovery implementation, may be useful to look at its source
1273. Ray Tracer In ASCII - Very simple code, easy to understand
1274. Sector Lisp - Lisp that fits in a boot sector, some crazy assembly tinkering here...
1275. That XOR Trick - Lots of use cases for xor
1276. CPP By Example - Exemplary snippets of C++ code, up-to-date
1277. Bit Hacks - _Lots_ of bit manipulation tricks
1278. Unicode Bidirectional Algorithm - Right from the standard
1279. Lock-Free Data Structures With Hazard Pointers - How to implement hazard pointers
1280. Curves And Surfaces - Yet another legendary article
1281. An Opinionated Guide On How To Reverse Engineer Software - Great intro to RE
1282. How An X Window Manager Works And How To Write One - Very nice overview
1283. How To Implement Accessible Focus Indicators - web-dev
1284. Geometry And Algorithms For CAD - Great book for learning more about CAD theory
1285. Ruled Surface - I've been trying to find the name for this kind of surface for so long...
1286. Catmull Clark Subdivision Surface - Algorithm for subdivision surfaces
1287. Anatomy Of A Terminal Emulator - Great article on how a terminal emulator works
1288. What Is The Inverse Of A Vector? - Great article on geometric algebra
1289. Curves and Surfaces for CAGD - Great reference on Beziers/B-Splines and anything related to CAD
1290. The Tale Of A Single Register Value - Fixing a bug in the linux kernel
1291. How Do Computers Draw Weird Shapes - Metaballs explained(marching squares)
1292. Learn Compilers: LLVM Edition - Lots of resources on learning compilers, including the back-end, also has courses on automata theory, turing machines and computational complexity
1293. How Credit Cards Make Money - How credit cards work
1294. Building A MIPS CPU In Hardcaml - Using ocaml for hardware design
1295. An Incremental Approach To Compiler Construction - Building a full compiler of scheme
1296. New LuaJIT Garbage Collector - WIP wiki on GCs in general, great to learn more about various GC algorithms
1297. Introduction To Concurrent Logic Programming - Title says it all
1298. Creating A Chess-Engine From Scratch - Alpha-Beta pruning in action
1299. Chess Programming Wiki - Learning chess engine techniques
1300. How To Learn Stuff Quickly - Learning how to learn
1301. Init Constructors And Init Array - `__attribute__((constructor))` and dynamic initialization under the hood
1302. A Unified Theory Of Garbage Collection - GC methods, really good paper
1303. Porth - Compiling a forth with python, includes the back-end
1304. Formal Methods - Overview of formal methods
1305. Classical Logic - Great article introduction logic
1306. A Problem Course In Mathematical Logic - Learning logic through practising problems
1307. Forall X - Great introductory book on formal logic
1308. Safety-Critical Systems, Formal Methods And Standards - How formal methods fit into safety-critical systems
1309. Guide To Prolog Programming - Contains lots of useful examples: sorting algorithms, graph algorithms etc.
1310. Thinking With Types - Properly Learning Haskell(and a bit about type systems in general)
1311. Practical Foundations Of Programming Languages - Learning type systems, extremely detailed
1312. The Reasoned Schemer - Extending the functional language Scheme with logical constructs in order to help the functional programmer think logically and the logic programmer think functionally
1313. Hypervisor From Scratch - Learn about hypervisors
1314. Theorem Proving In Lean4 - Learn more about proofs and lean4
1315. The Hitchhiker's Guide To Logical Verification - Learning interactive theorem proving with Lean
1316. Formal Verification For Dummies - Learning about low-level building blocks of formal verification
1317. The Little Typer - Intro To Dependent Types
1318. Standard ML For The Working Programmer - Learning Standard ML
1319. Reconstructing Typescript - How to implement a type checker
1320. Resolution Independent Path Rendering Of Dynamic Geometry - Rendering vector graphics, this time with animations
1321. Programming In Standard ML - Another great book on learning SML
1322. Spotify Codes - How Spotify generates QR codes
1323. Steering Behavior For Autonomous Characters - Could be used for path finding in an RTS game
1324. EasyLang - Great introductory programming language with a nice website
1325. Monte Carlo Methods, Or Why It's Bad To Go To The Casino - Some probability theory, also has a nice article on Blackjack
1326. How Do Timers Work? - Great video on hardware timers
1327. Neural Nets With C++ And SFML - A really nice and easy to understand video about neural nets and thei visualization
1328. Flappy Bird AI - A really fun video, showing a neural net and a genetic algorithm
1329. Everyday DSP For Programmers - Learning DSP with some really nice introductory material
1330. Locking In WebKit - How WebKit efficiently implements locking and condition variables
1331. Writing A Micro-Compiler In OCaml - Without OCamllex(though it includes a follow-up), generates a binary
1332. Cracking The Adventure Time Cipher - Fun little article
1333. MLVU - Great lectures on machine learning, teaches neural nets, deep learning, reinforcement learning and other stuff
1334. Transformers From Scratch - Great tutorial on transformers
1335. Wolves Make Roadways Safer - Interesting article on how wolves help keep the roads safe from deers
1336. Formalizing Dawn In Coq - Using Coq to formalize a programming language
1337. RPMalloc - A general-purpose memory allocator for C, it would be helpful to look at its source to learn more about memory allocators
1338. RetroClash - Book that teaches clash(while also building games on FPGA), seems fun
1339. Structures, Or Why Things Don't Fall Down - A great technical book that teaches structural mechanics
1340. Basic Civil Engineering - Introductory book to civil engineering, must read, contains chapters on buildings, water supply, transport engineering, etc.
1341. Surveying And Levelling - Great introductory book for surveying
1342. Computer Architecture: A Quantitative Aprpoach - Detailed book on low-level things
1343. Applied Differential Geometry - Great introductory book on physics
1344. Quite OK Image Format - A very simple compression algorithm
1345. Joy Of Cryptography - Book that introduces cryptography, great read
1346. Design And Implementation Of A JPEG Decoder - How to decode JPEG
1347. Unravelling The JPEG - Playing around with the JPEG format, great read
1348. Peritext - A CRDT For Rich Text
1349. Haskell-Math-Parser - An easy-to-understand arithmetic expression parser made in haskell, complete with a bytecode generator
1350. Haskell Calc - Similar to the above, but a bit more involved in parsing
1351. Haskell-Calculator - Also similar to the above, also a bit more involved on the parsing side
1352. Fastest FizzBuzz - How the fastest fizzbuzz algorithm's assembly works
1353. Mathematics Of The Discrete Fourier Transform - Incredibly thorough book on DFT
1354. WebGL Water - Interactive water simulation directly in WebGL
1355. Evan Wallace - Lots of interesting graphics projects that I could probably learn from
1356. Computer Systems: A Programmer's Perspective - Great book that teaches fundamental concepts in programming
1357. List Of Fallacies - Learning about wrong argumentation
1358. AsyncIO In C++ - Really easy to use, great for learning about coroutines, includes a generic event loop, with implementations for `epoll` and `kqueue`
1359. Shigley's Mechanical Engineering Design - Excellent book on mechanical engineering, contains lots of useful info
1360. Fundamental Of Thermodynamics - Great resource on thermodynamics
1361. Gentle Introduction To Realtime Fluid Simulation For Programmers And Technical Artists - Great write-up on how fluid simulations work
1362. Electrochemical Engineering - Learning about batteries & co.
1363. One-More-RE-Nightmare - Using Mealy machines for fast regex matching, in LISP
1364. Regular Expression Derivatives Reimagined - Learning about automata theory, regex derivatives in particular
1365. How Does NTP Work? - The network-time-protocol-explained in depth
1366. How Does WebRTC Work? - Learning more about the WebRTC protocol
1367. How Does LTE Work? - Understanding the LTE standard
1368. There And Back Again: The Unexpected Journey Of A Request - Where does an HTTP request go, when using kubernetes
1369. How Does DNS Work? - Yet another great resource on learning about DNS
1370. The Method To `epoll`'s Madness - Learning more about epoll
1371. Intro To Game Programming - Very interesting course, has some nice videos on ECS and particle systems
1372. Using Graph-Theory To Build A Simple Recommandation Engine In Javascript - search-engine
1373. ThreePP - Three.js in C++17, might learn about the design of a 3d lib
1374. Decompressing A Gzip By Hand - Learning more about Gzip, includes some nice references
1375. Understanding Zlib - Learning more about zlib
1376. Learn Haskell By Building A Blog Generator - Really nice way to learn Haskell, for a purpose it's really well-designed for: parsing
1377. A Guide To Good Reasoning: Cultivating Intellectual Virtues - A book that teaches critical thinking
1378. How To Become A Really Good Pain In The Ass: A Critical Thinker's Guide To Asking The Right Questions - Another good book on critical thinking
1379. The Thinker's Guide To Fallacies: The Art Of Mental Trickery And Manipulation - Yet another great book on critical thinking
1380. Sol: MQTT Broker From Scratch - Hands-on way to learn about MQTT
1381. ThorVG - VG library used in Tizen OS
1382. Text Editing Hates You Too! - In the style of 'Text Rendering Hates You!'
1383. Fast CSV Processing With SIMD - Really quick guide to processing CSV quickly
1384. Atomic Weapons - The C++ memory model and nodern hardware, properly learning about atomics, fences etc.
1385. University Of Washington Courses - A list similar to the MIT one
1386. A Brutally Efective Hash Function In Rust - Learning more about hashing
1387. Go Compiler Internals: Adding A New Statement To Go - Great read, teaches some go compiler internals
1388. Reverse-Engineering Roman Cavalry - Super interesting read
1389. Parallel Logic Programming: A Sequel - Learning about parallel logic programming
1390. Performance Analysis And Tuning On Modern CPUs - Learning about performance tuning
1391. The HoTT Game - Game for learning proofs in HoTT, really interesting
1392. Minimalist Guide To Lossless Compression - Learning more about lossless compression
1393. Everything You Never Wanted To Know About Linker Script - Learning more about linker scripts
1394. Little C++ Standard Library Utility: `std::align` - Seeing how `std::align` works
1395. WebGPU Compute Rasterizer - Building a rasterizer using compute shaders with WebGPU
1396. Meteora - Incredible place in Greece, with some nice monasteries
1397. How WebRender Gets Rid Of Jank - A great description of how webrender (and browser engines in general) work
1398. Mess With DNS - Great way to learn about DNS, hands-on
1399. How To Write A JIT Compiler - Easy-to-follow guide on writing a JIT
1400. Jone's Forth - A complete FORTH implementation in assembler, beautifully explained
1401. Leveraging SIMD: Splitting CSVs At 3GB/s - Another tutorial on csv + simd
1402. Electrical 4U - Lots of interesting articles regarding electrical engineering (and signal processing)
1403. Line-Line Intersections - How to calculate intersections between two lines
1404. Original Bitcoin Paper - Probably the most reliable learning resource regarding blockchains...
1405. Proof Of Stake - Also probably the only reliable source on learning the proof-of-stake method
1406. Designing A New PRNG - Great insight into what goes in a PRNG
1407. PCG Paper - Excellent paper that introduces PCG, though it's very accessible and contains useful info on PRNGs in general
1408. Implementing RSA In Python From Scratch - Seeing how RSA works on plain text
1409. Differentiable Programming In C++ - Great talk that introduces AD in general, with implementation gotchas
1410. Homotopy Type Theory - Great course on learning homotopy type theory
1411. Correctness Proofs For Device Drivers In Embedded Systems - Verifying Drivers
1412. Slides for the previous link - Title says it all
1413. Embedded In Academia - Really nice blog with articles on: compilers, verification, embedded, os-dev etc.
1414. Who Verifies The Verifiers - A high-level overview on the challenges of formal verification
1415. Contexts And Capabilities In Rust - A look at how an effects system would look in rust
1416. What Problems Blockchain Actually Solves - A very nice insight into blockchains and their advantages/disadvantages, includes some nice links too
1417. Understanding Blockchain Fundamentals: Byzantine Fault Tolerance - Great set of articles that dives into blockchains
1418. Transparent Logs For Skeptical Clients - Append-only temper-evident logs using merkle trees, but not a blockchain
1419. Ordering Movie Credits With Graph Theory - Really nice read, seeing how ordering credits comes to a graph theory problem
1420. Intuitive Advanced Cryptography - Lots of crypto concepts introduced here, really fun paper
1421. QOI Format - Updates to the 'quite-ok-image format'
1422. libgrapheme - Extremely simple Unicode lib for C99, could learn from its source
1423. How To Draw S-Curved Arrows Between Boxes - Like the ones in Draw.io or in game engines
1424. Line Breaking - Great article showing an implementation of line breaking
1425. Formally Verifying IA-64 Division - Using HOL to formally verify the division algorithm here
1426. On ELF, Part 2 - Interesting set of articles that describe the ELF format
1427. The Teensy Files - How to create really small ELF executables on linux, by hand
1428. ras52/bootstrap - Building a bootstrap compiler from scratch, starting from hex code
1429. BCompiler - Building a bootstrapping compiler from scratch, starting from hex code, similar to the above link
1430. Descriptions Of A Few Layout Algorithms - With nice, visual explanations, plus clean code explaining them
1431. Implementing Marching Squares - Having a go at a simple, naive implementation of marching squares
1432. TypeClassopedia - Learning Functor, Applicative, Minad, Bifunctor etc. with good explanations and examples
1433. Hindley Milner Type System Implementation - In standard ML
1434. Javascript Tutorial - An excellent tutorial on modern JS
1435. Game Programming Patterns - Not too in-depth, but still pretty good as a reference
1436. How To Self-Study Pure Maths - Lots of great resources on linear algebra, topology etc.
1437. Fixing Raleway And Similar Fonts' Numerals - Raleway but without oldstyle-aligned numbers
1438. Roll Your Own Network - A high-level overview on a lot of networking-related things, really great resource
1439. Category Theory Resources For An Enthusiast - Learning about CT
1440. Asynchronous I/O And Coroutines For Data Streaming - Converting an `epoll` framework to `io_uring`, using coroutines as well, also has live examples with code included, really nice for learning
1441. Linux Insides - Book introducing the inner workings of the Linux kernel
1442. Stellar Consensus Protocol - A consensus protocol that's simpler than most
1443. Writing A Minimal Lua Implementation With A Virtual Machine From Scratch In Rust - Implementing a simple VM for Lua, really easy to follow
1444. Building A RISC-V CPU In Typescript - Great videos, and great channel
1445. Methods For Terrain Generation - Title says it all
1446. Making Sounds Using SDL And Visualizing Them On An Oscilloscope - Great intro into audio programming (and DSP)
1447. CP-Algorithms - Exceptional guides on various well-known algorithmic challenges
1448. A Computational Approach To Edge Detection - Title says it all
1449. Debugging Concurrent Systems Using A Model Checker - Using TLA+ in practice
1450. Handbook Of Graph Drawing Algorithms - Great resource collection on graph-drawing algorithms
1451. Category Theory: Lecture Notes And Online Books - Yet another great resource for learning category-theory
1452. Programming Language Foundations In Agda - Excellent book for learning agda
1453. FizzBuzz Implementation - Not really special, it's just a different implementation, not one of the 'obvious' ones
1454. PortableGL - OpenGL 3.x imlpementation in clean C, great educational resource
1455. Proofs, Computability, Undecidability,Complexity, And the Lambda Calculus: An Introduction - Excellent resource on lambda calculus
1456. Measure Car Engine Speed RPM Via The Cigarette Lighter - Using DSP to measure RPM... really cool
1457. How Audio Fingerprinting Works - Music recognition behind the scenes
1458. How Shazam Works - Another great article on audio fingerprinting
1459. Write Yourself A Scheme In 48 Hours - Great tutorial on Haskell, very practical
1460. Awesome-Audio-DSP - Excellent collection of resources for learning DSP
1461. Parser Combinators In Haskell - How to implement parser combinators, really easy to read article
1462. Parser Combinators: A Walkthrough - Another great resource on implementing combinators
1463. Fun With Parsers - Yet another great resource on parser combinators
1464. Implementing Functional Languages: A Tutorial - An excellent book on implementing functional languages
1465. Continued Fractions And Their Application Into Fast Computation Of [nx] - Great insight into implementing floating point algos
1466. Interactive Linear Algebra - Excellent resource for learning linear algebra
1467. Introduction To Classical And Quantum Computing - Book that teaches quantum computing
1468. Parsing Techniques: A Practical Guide - Great book that teaches everything about parsing, including error handling
1469. Corth - Like Porth, but in C++: a compiler for forth (that generates assembly directly)
1470. Writing A Gameboy Emulator In OCaml - Excellent article describing the emulator, could be a really fun project
1471. Lambda Cube - Learning about lambda calculus and type theory
1472. Death Note: L, Anonimity & Eluding Entropy - An extremely interesting article describing how L found Kira by reducing the number of candidates with probability/statistics
1473. Probability Course - Learning probability theory
1474. Stat Trek - Learning statistics theory, very comprehensive resource
1475. The Noise Series - Deep dives, interactive guides into noise generation
1476. Neural Networks In Pure Lisp - Fascinating, excellent article that implements addition, multiplication, matrix multiplication in pure lisp; could also be a great way to learn about NNs
1477. PLS Lab - Similar to nLab, but for programming language theory
1478. Automata, Computability, Complexity Theory And Applications - Finally a good resource to learn about all of these things
1479. A Tour Of Metaprogramming Models For Generics - A really nice comparison between Go, Rust, C, C++, D, Java and how they do generics
1480. The Xi CRDT Text Engine - Really nice explanation of how the CRDT used in the Xi editor works
1481. Designing A Tree-Diff Algorithm Using Dynamic Programming And A* - Really great explanation for a tree-diffing algorithm
1482. GPS - Another excellent article from Bartosz, this time explaining how GPS works
1483. The Unreasonable Effectiveness Of JPEG: A Signal Processing Approach - Incredibly good, visual explanation of how JPEG works
1484. The Probability Of A Hash Collision - Really easy to understand explanation of hash collision probability
1485. Transformations By The Oracle Optimizer - Great article explaining optimizations of Oracle
1486. Reverse Engineering For Beginners - Excellent way to learn about RE
1487. LLisp: Lisp In Lisp - Writing a small Lisp interpreter that supports macros, really fun exercise
1488. Why Functional Programming Matters - Read it to learn why laziness matters
1489. Rust For Embedded C Programmers - Great article for learning Rust coming from C
1490. Bare Metal Register Access API - Great way to use C++ for embedded
1491. What Is The Strict Aliasing Rule And Why Do We Care - Finally a good resource that teaches the aliasing rule in C++
1492. Real Mode Assembly: Writing Bootable Stuff - A more advanced tutorial on bootloaders, it's a complete series, it even creates games in real-mode, it's an incredible resource
1493. Introduction To Probability For Data Science - Another great book on statistics
1494. Github Actions By Example - This could even be considered a ganeral intro into CI/CD
1495. The Odin Project - Great for web-dev beginners
1496. Newton's Cradle: Modelling And Animation - Excellent tutorial that creates some majestic graphics, could learn something more about materials from this
1497. Additive Synthesis: Bell Example - Some really concise and readable code that generates a real bell sound using additive synthesis
1498. Fornjot - A simple CAD program, it might be useful to look at its rendering code to learn more about efficient CAD rendering
1499. The Art Of Electronics - An excellent, comprehensive guide to electronics (and embedded in general)
1500. How To Make 3D Fractals - Amazing video that shows how 3D fractals work
1501. The Distance Estimator Compendium - Collection of distance estimators for various primitives
1502. Distance-Estimated 3D Fractals - Absolutely stunning/excellent tutorials on implementing 3D fractals with ray marching
1503. Bezier Surface In 3D - Learning more (again) about Bezier surfaces
1504. DDS C++ Package Manager - This looks really interesting since it doesn't use a build file, it deduces the build config from the filesystem
1505. Hoare’s Rebuttal And Bubble Sort’s Comeback - Or: how to make QuickSort faster, an evolution of 'Lomuto's comeback'
1506. What Is The Inverse Of A Cricle - Excellent article on complex numbers
1507. Unsafe Rust Is Too Hard - How to work with uninitialized data in Rust
1508. Systemd By Example - Finally a great resource to learn about systemd
1509. Writing A Toy `traceroute` - Very useful for learning more about networking
1510. A Survey Of Programming Languages Memory Models - Finally a great resource that looks at various memory models
1511. Programming Language Memory Models - Learning more about memory models, part 2
1512. GNU Name System - A secure alternative to DNS, could be a great doc to read to learn more about design with security from the start
1513. MIT: Database Systems Course - This course makes you implement an SQL database with a query parser and optimizer
1514. CppMem: Interactive C/C++ Memory Model - Not the most easily-digestable, but it's still cool to look at what happens with code that uses atomics
1515. A Relaxed Guide To `std::memory_order_relaxed` - Seeing the use-cases for `std::memory_order_relaxed`
1516. A DNS Resolver In 80 Lines Of Code - Excellent way to learn more about DNS, and what a 'real' DNS has
1517. 879 GB/s Parallel Reductions In C++ & CUDA - Excellent intro to HPC with C++
1518. Ray Marching Tutorial - A great way to start making cool outputs with ray marchers, presents a complete shader, then I can go to more 'advanced' tutorials
1519. Modern Compiler Implementation In ML - Excellent book to learn about compiler development
1520. Summary Of The FlexSC Paper - Why it's better to have a separated thread for syscalls
1521. Prototyping A Functional Language Using Higher-Order Logic Programming: A Functional Pearl On Learning The Ways Of Lambda-Prolog/Makam. This specifies complex language semantics as configs, kind of similar to K-framework - This is a must read after I familiarize myself more with logic/type theory
1522. Building A Wavetable Synthesizer From Scratch With Rust, WebAssembly, And WebAudio - A great way to make interactive synths directly on the web with Rust + WASM
1523. WebAssembly/Rust Tutorial: Pitch-Perfect Audio Processing - Making a basic guitar tuner with Rust and WASM
1524. WASM By Example: Reading And Writing Audio - Easy to understand tutorial on working with audio using Rust and WASM
1525. Lock-Freedom Without Garbage Collection - tutorial
1526. Elements Of Information Theory - _The_ book on information theory
1527. Learn Embedded Software Engineering - A great way to learn more about embedded development
1528. SHA-256 Explained Visually - Really nice view of SHA-256
1529. On Finding The Average Of Two Unsigned Integers - How to average 2 integeres correctly
1530. HoTT Book - A friendlier intro into HoTT
1531. How PostgreSQL Stores Rows - Excellent article that dives into PostregSQL's heaps
1532. Computational Physics Book - Great book that teaches compphys, including Runge-Kutta methods and monte-carlo methods
1533. Testing Distributed Systems - Great compilation of resources, there's more out there than TLA+, there's even Coq (Verdi)
1534. Typed Embedded DSL Directly In Go - Extremely interesting...
1535. Version SAT - Dependency Hell is NP-Complete (how to convert 3-SAT to dependency hell)
1536. Music Theory For Nerds - Great intro into sound theory from the perspective of a programmer
1537. Faster Integer Formatting - Great deep-dive intro printing integers
1538. Static B-Tree - A really interesting data structure that's a faster binary tree
1539. CUP - Educational Bootstrapping Compiler - Could learn from its source, contains codegen
1540. OCaml From The Very Beginning - Great intro to OCaml
1541. Things That Used To Be Hard And Are Now Easy - This could be considered as a list of nice things that you can use for the infrastructure of a new project
1542. Writing An SMTP Server In Go - Not a full server, but it can receive mails
1543. Practical Theory Of Programming Languages - Pretty easily-digestable PLT book
1544. Graph Theory Book - Undergraduate-level, looks really good
1545. Nix Flakes: An Introduction - Great way to start with flakes
1546. Python Behind The Scenes - Great articles that dive deep into python's inner workings
1547. Cross-Platform Ray Tracing App With Qt 6.2 - What it takes to run a Qt app on Win/Mac/Linux/Android/iOS
1548. Rendering Cubic Bezier Patches - Learning about rendering Bezier shapes
1549. Bezier Surfaces - Learning more about Bezier surfaces
1550. Bezier Surfaces: Construction - Yet another resource on Bezier shapes
1551. Presentation About Bezier Shapes - Yet another one...
1552. Interpolation Methods - Great summary of some interpolation methods
1553. An Almost Perfect Rsync Over SSH Backup Script - Comments are useful, maybe consider using Borg over rsync
1554. Purely Functional Data Structures - Lots of resources for learning about purely functional data structures
1555. Information Retrieval Book - Finally a great book on search engines
1556. Logic And Proofs - Great introductory book on logic and proofs that teaches Lean
1557. Lambda Calculus In 400 Bytes - Excellent article that shows SectorLambda, this could even be a great CS course
1558. Lambda Way - Learning lambda calculus, excellent resource
1559. Programming With Nothing - Ruby, but only with procs
1560. To Disect A Mockingbird - Yet another excellent resource for learning lambda calculus
1561. To Mock A Mockingbird - Classic book on lambda calculus
1562. Practical File System Design - Excellent book on file system from the guy that worked on/created the BeOS FS
1563. How To Make MPAs That Are As Fast As SPAs - Pretty interesting way to use MPAs
1564. Bytecode Compilers And Interpreters - Very easy to follow tutorial on writing interpreters
1565. Understanding Digital Signal Processing - Excellent, practical book on DSP
1566. Music And Computers - How music is represented in computers, great to get more familiar with terminology
1567. The Audio Programming Book - Nice practical book that teaches music programming
1568. Algorithms, 4th Edition - A great alternative to 'Introduction To Algorithms', that's a bit less theoretical (and it's free)
1569. Levenshtein Automata - Levenshtein, but for searching
1570. Sampling Floating Point In The Unit Interval - How to sample correctly
1571. So You Want To Study Mathematics... - Great guide for learning parts of math
1572. CryptoCoding - Guidelines for low-level crypto software
1573. Ray Tracing With M-Reps - Ray tracing Bézier curves directly
1574. The Computer Music Tutorial - Finally a resource that fouses on DSP in the context of music
1575. Maths-Music - Very in-depth, looks incredibly useful
1576. Nandland - Excellent resources for learning verilog/VHDL/FPGA development
1577. Circles, Sines, Signals - _Excellent_ interactive intro to DSP, also has an amazing explanation for Nyquist theorem making an analogy to cameras recording a wheel spinning
1578. Introduction To Computing With Geometry - Notes on a course on geometry, touches Bézier curves and splines
1579. Embedded RTOS Design And Implementation - How to build an RTOS
1580. How NAT Traversal Works - Deep dive into NAT traversal
1581. Fox Rust's Unsafe Pointers - Really interesting articles explaining all kinds of stuff regarding pointers (in Rust) from a compiler perspective, and looks at the CHERI architecture
1582. Max Function With Genetic Algorithms - Fun way to practice with genetic algorithms
1583. ChucK - Programming language for creating music
1584. Glicol - DSP music creation programming language
1585. SuperCollider - Yet Another DSP programming language
1586. Geometric Algebra Course - Great course for learning geometric algebra, the channel has a lot more useful videos regarding maths and complex numbers (even physics), check the other videos out as well
1587. Neural Network From Scratch - Easy to understand way to implement neural networks
1588. Haskell - Get A Brain - Building a Neural Network from scratch in Haskell
1589. Refactoring A Neural Network Implementation In Haskell - Refactoring the NN at the previous link
1590. GPU Ray-Casting With Python - Great tutorial on implementing ray-casting
1591. Based Cooking - No BS cooking recipes
1592. Cooking For Engineers - Another fun cooking website
1593. Learn SHA-256 By Implementing It - Also contains a section that presents the 'Length Extension Attack'
1594. Ray Tracing From Scratch - A great presentation that shows how ray tracing works, it's easy to understand and implements intersections with triangles right from the start
1595. C++ Vs. SML Ray-Tracer Comparison - Fun little comparison between SML amd C++, contains a very concise acceleration structure implementation
1596. Cosine From Scratch - How to implement `cos`
1597. Writing A Document Database From Scratch In Go - Lucene-like API
1598. Generics Can Make Your Go Code Slower - tutorial
1599. Markov Chains For Programmers - Learning about markov chains
1600. Adventure In Prolog - Learning Prolog by making an adventure game, includes stuff on NLP
1601. Rehabilitation Of Gamma - In-depth article about gamma correction and how to use color _properly_
1602. How Postgres Chooses Indexes - Great insight into Postgres' codebase
1603. Discussion regarding ARC vs GC - Some great insights from people describing advantages/disadvantages of ARC vs GC, the Vale dev explains well why python chooses a GIL
1604. How To Build A BVH - Finally a step-by-step guide on building a BVH
1605. Let's Program A Calculus Student - Writing a function differentiator as a DSL in Haskell
1606. Learn Physics By Programming In Haskell - Really fun paper that describes Newtonian mechanics and electromagnetic physics in Haskell
1607. Mechanical Watches - Fantastic presentation of mechanichal watches' inner workings
1608. Differentiable Signed Distance Function Rendering - Differentiable rendering, this time for 3D shapes
1609. Automatic Differentiation: Forward And Reverse - Excellent blog post that implements autodiff in Rust from scratch. Also has a ton of nice resources referenced
1610. Cron Job For Backing Up SQLite - Litestrean alternative for simple use-cases
1611. Rendering Elliptical Arcs As Cubic Bézier Curves - Contains useful info on converting from SVG arc notation to parametric notation
1612. Mesh Gradients Rendering In Vector Graphics - Very nice overview of rendering gradient meshes
1613. SVG2 Mesh Gradient Rendering In Haskell - Actual rendering of mesh gradients in Haskell
1614. Formalizing Gödel's Incompleteness Theorems - A nice way to learn Isabelle/HOL
1615. Implementing Dependent Types - How dependent types work, look at references
1616. Full Website From The Previous Link - A lot of interesting stuff done in JS, including a piano and a microprocessor, besides PLT stuff
1617. Verified Quantum Computing - Learning about quantum computing
1618. DIY Synth - How to implement a synth in C++ by writing WAV files
1619. Fast Pipes - Great article describing how to do profiling and improving performance
1620. Cascada Văii Rele - Nucșoara, Argeș
1621. How To Build A RayTracer - GOU Ray Tracing, covers a lot of stuff about ray traycers, nice step-by-step tutorial
1622. Haskell Model Checking - Implementing an imperative programming language and deriving parallel programs
1623. Functional Algorithms Verified - Nice, clean and correct implementations of various algorithms/data structures
1624. Refinement Types: A Tutorial - Learning about refinement types
1625. Algorithms Visualized - Exceptional visualisations of various algorithms, include maze generators
1626. Learn TLA+ - TLA+ with advanced examples
1627. Writing A SAT Solver - How SAT solvers work, in Haskell
1628. SAT Solvers By Example - In-depth tutorial on implementing SAT-solvers
1629. Comparing Floating Points Is Tricky - Learning more about floating points, especially comparisons
1630. The Joys And Perils Of Beating C With Haskell - Reimplementing `wc` and optimizing it
1631. SMT Solvers: Theory And Practice - Learning about SMT solvers
1632. Parsing GNU Tar - Why GNU tar extracts in quadratic time, and some nice details of the tar format
1633. Formally Verifying Rust's Opaque Types - A practical guide to formal verification in Coq
1634. Interactive LR(1) Parsers - Great way to learn more about parsing
1635. Vector Graphics On The GPU - Kind of how Pathfinder works
1636. From Oscilloscopes To Wireshark: A UDP Story - Networking all the way down to the PCB
1637. Algorithms For Systems Engineering - Loads of stuff for distributed systems, great resources
1638. 1 Billion Is Tiny In An Alternate Universe - Learning about p-adics
1639. Understanding And Implementing Type Classes - Methods for implementing type classes in Haskell
1640. Comparing Rust's And C++'s Concurrency Library - Great insight into what each language provides concurrency-wise
1641. Crabs All The Way Down - Building a computer from scratch
1642. CPU From Scratch - With an assembler written for that CPU, great educational project
1643. Bilinear Texture Filtering: Artifacts, Alternatives, and Frequency Domain Analysis - Deep dive into texture filtering methods, great DSP learning exercise
1644. Project Oberon - OS made from scratch, probably useful to study CPU design, with an assembler made for that CPU
1645. Luz - Assembler, Linker And CPU Simulator - Basically a full computer built from scratch
1646. Practical Typography - Lots of great stuff about typography
1647. Compiling With Continuations - From the same author of 'Modern Compiler Implementation In ML'
1648. Compiling With Continuations: With Or Without? Whatever. - A nice paper describing techniques for CPS
1649. What Is An LSM Tree - Detalied Explanation Of LSM Trees
1650. Compiling Pattern Matching - Useful for writing a compiler for a functional language
1651. Compiling Lambda Calculus - What the title says
1652. ML From Scratch - Very simple implementations of some ML algorithms in Python using only NumPy
1653. Automatic Differentiation In 38 Lines Of Haskell - Probably useful for ML
1654. Factorial Using Lambda Calculus - Compiling untyped lambda calculus to x86
1655. T3X - Exceptional resources for learning about compilers
1656. Fast, precise flattening of cubic Bézier path and offset curves - Flattening and stroking cubic Bézier curves
1657. Vector Graphics In A Shader - Very nice implementation, with animated graphics
1658. 2D Graphics Primitives - A nice write-up of various 2D primitives (lines, curves, arcs etc.)
1659. Drawing An Elliptical Arc Using Polylines, Quadratic Or Cubic Bézier Curves - How to approximate elliptical arcs
1660. HomebrewGPU - Ray Tracing on an FPGA
1661. Briand Douglas - Control Theory Courses
1662. Prolog Tutorial - Excellent Prolog tutorial with lots of practical examples, with actual use-cases for Prolog
1663. Checking Statistical Properties Of Protocols Using TLA+ - Practical TLA+ tutorial
1664. Discussion On A Simple Strategy For Generating Strokes - From Patrick Walton
1665. Computer-Aided Geometric Design - Some notes on CAD implementation details, very informative
1666. Precise Flattening Of Cubic Bézier Curves - A non-recursive flattening algorithm for cubics
1667. How Ray Tracing (Modern CGI) Works And How To Do It 600x Faster - Explaining ray tracing with importance sampling, reservoir sampling, spatial reuse and temporal reuse (with linked papers)
1668. Type Inference - Exemplifying type inference for a toy ML-lang in Python
1669. Verifying Distributed Systems With Isabelle/HOL - Great lecture on formal verification
1670. Learning Dynamic 3D Geometry And Texture For Video Face Swapping - The maths behind face swapping effect
1671. Synthesizing A Pluked String Sound With The Karplus-Strong Algorithm - Making a guitar noise, very simple to implement
1672. LISP Implemented In Haskell - LISP interpreter written in Haskell, with a CLI included; also contains a nice comparison between Haskell and LISP
1673. Programming And Proving In Agda - Learning Agda
1674. How To Write A Bootloader From Scratch - For Cortex-M, lots of great info
1675. How To Debug A Hardfault - On Cortex-M, lots of great info, especially regarding which registers mean what
1676. Comparing TCP and QUIC - Very in-depth explanation of QUIC in comparison to TCP, with its advantages
1677. Jump Point Search Explained - An optimization to A* for uniform-cost grids
1678. Building A BitTorrent Client From The Ground Up In Go - tutorial
1679. How Do One-Time Passwords Work? - Great insight into authentication apps' inner workings
1680. Programming Language Explorations - Book comparing various programming languages with diverse paradigms, seems interesting
1681. Concepts, Techniques, And Models Of Computer Programming - Another book comparing various programming language paradigms
1682. C++20 Coroutines And `io_uring` - Using coroutines with io_uring, this might be a good way to learn about io_uring
1683. Let's Write A Tiny Chess Engine In Go - A small chess engine with alpha/beta pruning
1684. Inside boost::unordered_flat_map - Great dive into a SIMD-accelerated hash table using open addressing
1685. SPARK By Example - Examples of algorithms implemented in Ada SPARK
1686. Building A BFT JSON CRDT - Implementing a CRDT with Byzantine fault tolerance
1687. `io_uring` Man Page From Arch Linux - It contains a good, simple example using STDIN, much clearer now
1688. A Friendly Abstraction Over `kqueue` And `io_uring` - How to build an async runtime
1689. RISC-V Processor In Verilog - Very concise implementation, contains a link in the comments with explanation
1690. The Wave-Function Collapse Algorithm Explained Very Clearly - A good intro to Wave-Function Collapse
1691. Optimizing UTC → Unix Time Conversion For Size And Speed - Converting from UTC to Unix Timestamp
1692. Continuity Of Splines - Great math explainer for the math behind continuity of Bezier curves
1693. How To Write An Eulerian Fluid Simulator With 200 Lines Of Code - Very easy to understand
1694. From Zero To Main - How to write firmware
1695. Another Nice Ray-Matched Animation - With demo and code
1696. Faster Virtual Machines: Speeding Up Programming Language Execution - How to write an interpreter
1697. Tar.PL - Tar creator + extractor in 100 lines of Prolog
1698. Approximate A Cricle With Cubic Bézier Curves - A pretty simple solution
1699. The Typographic Scale - A nice typography insight
1700. How To Read ARM64 Assembly - A simple tutorial on ARM64
1701. A Guide To ARM64 / AArch64 Assembly On Linux With Shellcodes And Cryptography - Another, more detailed guide on ARM64 assembly
1702. Make A Resume In LaTeX - Great guide on creating a CV from scratch in LaTeX
1703. Minimal Cross-Platform Graphics - Could be very useful for creating demos for a vector-graphics library
1704. Designing A CPU In VHDL - How a CPU works
1705. Message Passing And The Actor Model - Tutorial on understanding the fundamentals of Erlang
1706. Mysteries Of The SPI Protocol - Learning about SPI
1707. The Winding Order Of The Fill Rule - Understanding how to implement the even-odd and non-zero fill rule
1708. Type Inference That Sticks - Intercative type inference - might be a great resource for when you want to implement _that_ language
1709. GPT In 60 Lines Of NumPy - A very basic implementation of a GPT, could be a great starting point in understanding how it works
1710. What Is ChatGPT And Why Does It Work? - A much more detailed explanation on how ChatGPT works
1711. A Lambda Calculus With Stackful Coroutines - With TCO, and other optimizarions, great reference for implementing a language
1712. Modern Microprocessor - A general guide on microprocessors, pretty high level but still pretty useful
1713. Never Use Git Submodules - tutorial
1714. Basics Of Compiler Design - Digestible book on compilers, includes sections about symbol tables and type checking
1715. Formal Algorithms for Transformers - Learning the inner workings of large language models
1716. How To Run Your Own LLM (GPT) - Another great, detailed resource on how to learn LLMs
1717. TCO, CPS And Trampolines - Exploring how to do TCO in a language without TCO, very informative
1718. Shooting Yourself In The Foot With PostgreSQL - Various tips and tricks for using Postgres in production
1719. PG Tune - Postgres config generator; can be helpful for setting OK parameters for Postgres
1720. Don't Do This (PostgreSQL) - Insightful wiki on advice on how to use PostgreSQL properly
1721. Transformers From Scratch - Another great tutorial on transformers
1722. Efficient Rendering Of Linear Brush Strokes - How to draw brushes without actually sampling from a texture
1723. The Little Book Of Deep Learning - Another great resource for learning about ML
1724. How does an FPGA Work - Great reference on FPGAs
1725. Paradigms Of Artificial Intelligence Programming: Case Studies In Common Lisp - Great book, explains how to implement a Prolog and a compiler for Lisp as well
1726. Hull-Dobell Theorem - Generating numbers in a range randomly, without repetition, covering the whole range
1727. An Introduction To TLA+ - Pizza Party: great intro into TLA+
1728. Bare-Metal Programming Series - In-depth videos on how to interact with a microcontroller and write firmware for it
1729. Implementing DNS In A Weekend - Great tutorial that teaches how to implement a DNS resolver
1730. EGOS 2000 - An educational operating system that serves as a reference to how OSes work. It can run on QEMU or a RISC-V board
1731. SQL API In OCaml Using GADTs - Practical use for GADTs, great reference for how an SQL interface could be implemented
1732. U-Net CNN in APL: Exploring Zero-Framework, Zero-Library Machine Learning - ML from scratch in APL
1733. Coalton - Statically-typed functional programming language on top of Common Lisp
1734. Typing Haskell In Haskell - Haskell program that implements a Haskell type checker
1735. SSA-Based Compiler Design - Detailed book about SSA
1736. The Static Single Assignment Book - Great book about learning SSA
1737. Resources For Amateur Compiler Writers - Lots of good reading material for writing a compiler