> For the complete documentation index, see [llms.txt](https://docs.exohood.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.exohood.com/resources/open-library.md).

# Open Library

### AI

* [Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp](https://github.com/norvig/paip-lisp) by *Peter Norvig*

#### Machine Learning

* [A Course in Machine Learning](http://ciml.info) by *Hal Daumé III*
* [Algorithms for Decision Making](https://algorithmsbook.com) by *Mykel J. Kochenderfer*, *Tim A. Wheeler*, and *Kyle H. Wray*
* [Deep Learning](https://www.deeplearningbook.org/) by *Ian Goodfellow, Yoshua Bengio and Aaron Courville*
* [Deep Learning Interviews](https://github.com/BoltzmannEntropy/interviews.ai) *Second Edition* by *Shlomo Kashani*
* [Dive into Deep Learning Compiler](https://tvm.d2l.ai/)
* [Machine Learning Engineering Book](http://www.mlebook.com/wiki) by *Andriy Burkov*
* [Mathematics for Machine Learning](https://mml-book.github.io/) by *Marc Peter Deisenroth, A. Aldo Faisal, and Cheng Soon Ong*
* [Physics-based Deep Learning](https://physicsbaseddeeplearning.org/intro.html) by *N. Thuerey, P. Holl, M. Mueller, P. Schnell, F. Trost, K. Um*
* [The Hundred Page Machine Learning Book](http://themlbook.com/wiki) by *Andriy Burkov*

#### Computer Games AI

* [Game AI Pro](http://www.gameaipro.com) by *Steve Rabin*
* [Programming Starcraft AI](https://makingcomputerdothings.com/an-index-for-the-starcraft-ai-posts) by *Peter Kis*

### Algorithms

* [Algorithms](http://jeffe.cs.illinois.edu/teaching/algorithms/) by *Jeff Erickson*
* [Algorithms for Optimization](https://algorithmsbook.com/optimization) by *Mykel J. Kochenderfer* and *Tim A. Wheeler*
* [Algorithms for Modern Hardware](https://en.algorithmica.org/hpc) by *Sergey Slotin*
* [The Arcane Algorithm Archive](https://www.algorithm-archive.org/)
* [Competitive Programming Algorithms](https://cp-algorithms.com/)
* [Competitive Programmer's Handbook](https://cses.fi/book/index.php) by *Antti Laaksonen*
* [Exact String Matching Algorithms](http://www-igm.univ-mlv.fr/~lecroq/string) by *Christian Charras and Thierry Lecroq*
* [Introduction to High Performance Scientific Computing](https://web.corral.tacc.utexas.edu/CompEdu/pdf/stc/EijkhoutIntroToHPC.pdf) by *Victor Eijkhout* with *Edmond Chow* and *Robert van de Geijn*
* [Principles of Algorithmic Problem Solving](https://www.csc.kth.se/~jsannemo/slask/main.pdf) by *Johan Sannemo*
* [Problem Solving with Algorithms and Data Structures using Python](https://runestone.academy/runestone/books/published/pythonds/index.html) by *Brad Miller and David Ranum*

### Command line and tools

* [Curl Cookbook](https://catonmat.net/cookbooks/curl)
* [Curl Exercises](https://jvns.ca/blog/2019/08/27/curl-exercises) by *Julia Evans*
* [How I'm still not using GUIs: A guide to the terminal](https://lucasfcosta.com/2019/02/10/terminal-guide-2019.html) by *Lucas Fernandes da Costa*
* [The Linux Command Handbook](https://www.freecodecamp.org/news/the-linux-commands-handbook) by *Flavio Copes*

### Compilers and Interpreters

* [Build Your Own Lisp](https://buildyourownlisp.com) by *Daniel Holden*
* [Crafting Interpreters](http://craftinginterpreters.com) by *Robert Nystrom*
* [Creating the Bolt Compiler](https://mukulrathi.co.uk/create-your-own-programming-language/intro-to-compiler) by *Mukul Rathi*
* [How Clang Compiles a Function](https://blog.regehr.org/archives/1605) by *John Regehr*
* [How LLVM Optimizes a Function](https://blog.regehr.org/archives/1603) by *John Regehr*
* [Let's Build a Compiler](https://xmonader.github.io/letsbuildacompiler-pretty) by *Jack Crenshaw*
* **Let's Write a Compiler** by *Brian Robert Callahan*
  * [Part 1: Introduction, selecting a language, and doing some planning](https://briancallahan.net/blog/20210814.html)
  * [Part 2: A lexer](https://briancallahan.net/blog/20210815.html)
  * [Part 3: A parser](https://briancallahan.net/blog/20210816.html)
  * [Part 4: Testing](https://briancallahan.net/blog/20210817.html)
  * [Part 5: A code generator](https://briancallahan.net/blog/20210818.html)
  * [Part 6: Input and output](https://briancallahan.net/blog/20210819.html)
  * [Part 7: Arrays](https://briancallahan.net/blog/20210822.html)
  * [Part 8: Strings, forward references, and conclusion](https://briancallahan.net/blog/20210826.html)
* [Make A Language](https://arzg.github.io/lang) - A series about making a programming language called *Eldiro* using the *Rust* programming language.

### Computer Graphics

* [3D Game Shaders For Beginners](https://github.com/lettier/3d-game-shaders-for-beginners)
* [3D Math Primer for Graphics and Game Development](https://gamemath.com/book/intro.html) by *Fletcher Dunn* and *Ian Parberry*
* [A Primer on Bézier Curves](https://pomax.github.io/bezierinfo)
* [Computer Graphics from Scratch](https://gabrielgambetta.com/computer-graphics-from-scratch) by *Gabriel Gambetta*
* [Curves and Surfaces](https://ciechanow.ski/curves-and-surfaces) by *Bartosz Ciechanowski*
* **GPU Gems Books Series**
  * [GPU Gems](https://developer.nvidia.com/gpugems/gpugems/contributors)
  * [GPU Gems 2](https://developer.nvidia.com/gpugems/gpugems2/copyright)
  * [GPU Gems 3](https://developer.nvidia.com/gpugems/gpugems3/contributors)
* [GPU Performance for Game Artists](http://fragmentbuffer.com/gpu-performance-for-game-artists) by *Keith O’Conor*
* [I Am Graphics And So Can You](https://www.fasterthan.life/blog) - a series of blog posts about implementing a Vulkan renderer for Doom 3 by *Dustin H. Land*
* [Learn Computer Graphics From Scratch](https://www.scratchapixel.com)
* [Learn OpenGL](https://learnopengl.com) by *Joey de Vries*
* **Probability Theory for Physically Based Rendering** by *Jacco Bikker*
  * [Part 1](https://jacco.ompf2.com/2019/12/11/probability-theory-for-physically-based-rendering)
  * [Part 2](https://jacco.ompf2.com/2019/12/13/probability-theory-for-physically-based-rendering-part-2)
* [The Book of Shaders](https://thebookofshaders.com/) by *Patricio Gonzalez Vivo and Jen Lowe*
* [Vulkan Guide](https://vkguide.dev)
* [Vulkan Tutorial](https://vulkan-tutorial.com) by *Alexander Overvoorde*
* [WebGL2 Fundamentals](https://webgl2fundamentals.org/)

#### Ray Tracing

* [How to build a BVH](https://jacco.ompf2.com/2022/04/13/how-to-build-a-bvh-part-1-basics) by *Jacco Bikker*
* [NVIDIA Vulkan Ray Tracing Tutorials](https://github.com/nvpro-samples/vk_raytracing_tutorial_KHR)
* [Physically Based Rendering: From Theory To Implementation](https://www.pbr-book.org/) by *Matt Pharr*, *Wenzel Jakob*, and *Greg Humphreys*
* [Ray Tracing Gems](https://link.springer.com/book/10.1007/978-1-4842-4427-2) by *Eric Haines and Tomas Akenine-Möller*
* [Ray Tracing Gems II](https://link.springer.com/book/10.1007/978-1-4842-7185-8) by *Adam Marrs, Peter Shirley, and Ingo Wald*
* [Ray Tracing in One Weekend: The Book Series](https://raytracing.github.io) by *Peter Shirley*
* [Vulkan Raytracing Tutorials](https://iorange.github.io)

### Computer Networks and Network Programming

* [An Introduction to Computer Networks](http://intronetworks.cs.luc.edu/current2/html) by *Peter L. Dordal*
* [Computer Networks: A Systems Approach](https://book.systemsapproach.org) by *Larry Peterson and Bruce Davie*
* [Computer Network Tutorials](https://www.geeksforgeeks.org/computer-network-tutorials)
* [HTTP2 Explained](https://daniel.haxx.se/http2) by *Daniel Stenberg*
* [HTTP/3 explained](https://http3-explained.haxx.se) by *Daniel Stenberg*
* [Networking 101](https://internalpointers.com/post-group/networking-101) by *Internal Pointers*
* [REST Servers in Go](https://eli.thegreenplace.net/2021/rest-servers-in-go-part-1-standard-library) by *Ely Bendersky*

### Cryptography

* [A Graduate Course in Applied Cryptography](https://toc.cryptobook.us) by *Dan Boneh* and *Victor Shoup*
* [Practical Cryptography for Developers](https://cryptobook.nakov.com) by *Svetlin Nakov*

### Databases

* [The Theory of Relational Databases](http://web.cecs.pdx.edu/~maier/TheoryBook/TRD.html) by *David Maier*

### Design Patterns

* [Data-Oriented Design](https://www.dataorienteddesign.com/dodbook) by *Richard Fabian*
* [Design Patterns & Refactoring](https://sourcemaking.com) *SourceMaking*
* [From design patterns to category theory](https://blog.ploeh.dk/2017/10/04/from-design-patterns-to-category-theory) by *Mark Seemann*
* [Game Programming Patterns](http://www.gameprogrammingpatterns.com) by *Robert Nystrom*
* [The Architecture of Open Source Applications](http://aosabook.org/en/index.html)

### Distributed systems

* [Testing Distributed Systems](https://asatarin.github.io/testing-distributed-systems) - Curated list of resources on testing distributed systems by *Andrey Satarin*.

### Game Programming

* [2D Game Development: From Zero To Hero](https://therealpenaz91.itch.io/2dgd-f0th) by *Daniele Penazzo*
* [Gentle Introduction to Realtime Fluid Simulation for Programmers and Technical Artists](https://shahriyarshahrabi.medium.com/gentle-introduction-to-fluid-simulation-for-programmers-and-technical-artists-7c0045c40bac) by *Shahriar Shahrabi*
* [Retro Rampage](https://github.com/nicklockwood/RetroRampage) a tutorial series in which you will learn how to build a Wolfenstein-like game from scratch, in Swift by *Nick Lockwood*
* [Reverse engineering the rendering of The Witcher 3](https://astralcode.blogspot.com/2018/11/reverse-engineering-rendering-of.html)
* [Scroll Back: The Theory and Practice of Cameras in Side-Scrollers](https://docs.google.com/document/d/1iNSQIyNpVGHeak6isbP6AHdHD50gs8MNXF1GCf08efg/pub) by *Itay Keren*

### GUI Programming

* [A Book about Qt5](https://qmlbook.github.io)
* [Sol on Immediate Mode GUIs](http://sol.gfxile.net/imgui)

### Hardware

* [Modern Microprocessors: A 90-Minute Guide!](http://www.lighterra.com/papers/modernmicroprocessors) by *Jason Robert Carey Patterson*
* [Processor Design: An Introduction](http://www.gamezero.com/team-0/articles/math_magic/micro)

### Logical Games

* [Hex: A Strategy Guide](http://www.mseymour.ca/hex_book) by *Matthew Seymour*

### Math

* [A Gentle Introduction to Tensors](https://www.ese.wustl.edu/~nehorai/Porat_A_Gentle_Introduction_to_Tensors_2014.pdf) by *Boaz Porat*
* [A Programmer's Introduction to Mathematics](https://pimbook.org/) by *Jeremy Kun*
* [An Infinitely Large Napkin](https://venhance.github.io/napkin/Napkin.pdf) by *Evan Chen*
* [Approved Textbooks](https://aimath.org/textbooks/approved-textbooks) of the [*American Institute of Mathematics*](https://aimath.org/)
* [Book of Proof](https://www.people.vcu.edu/~rhammack/BookOfProof), Third Edition by *Richard Hammack*
* [Books by *Dr. Kenneth Kuttler*](https://klkuttler.com/)
* [Calculus Made Easy](http://calculusmadeeasy.org/) by [*Silvanus P. Thompson*](https://en.wikipedia.org/wiki/Silvanus_P._Thompson)
* [Euclid's Elements](https://mathcs.clarku.edu/~djoyce/java/elements/toc.html)
* [Paul's Online Math Notes](https://tutorial.math.lamar.edu/) by *Paul Dawkins*

#### Algebra

* [Algebra: An Elementary Text-Book](http://onlinebooks.library.upenn.edu/webbin/book/lookupid?key=olbp36404) by [*George Chrystal*](https://en.wikipedia.org/wiki/George_Chrystal)
* [Immersive Linear Algebra](http://immersivemath.com/ila/index.html) by *J. Ström, K. Åström, and T. Akenine-Möller*
* [Interactive Linear Algebra](http://textbooks.math.gatech.edu/ila) by *Dan Margalit and Joseph Rabinoff*
* [Intermediate Algebra](https://saylordotorg.github.io/text_intermediate-algebra/index.html) by *Saylor Academy*

#### Category Theory

* [Category Theory for Programmers](https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface) by *Bartosz Milewski*
* [Category Theory Illustrated](https://boris-marinov.github.io/category-theory-illustrated) by *Boris Marinov*
* [Category Theory: Lecture Notes and Online Books](https://www.logicmatters.net/categories/) - collection by *Peter Smith*

#### Probability and Statistics

* [Digital textbook on probability and statistics](https://www.statlect.com) by *Marco Taboga*
* [Introduction to Probability for Data Science](https://probability4datascience.com/index.html) by *Stanley H. Chan*
* [Markov Chains for programmers](https://czekster.github.io/markov) by *Ricardo M. Czekster*
* [Seeing Theory](https://seeing-theory.brown.edu) - a book about statistics with interactive visualizations by *Daniel Kunin, Jingru Guo, Tyler Dae Devlin, and Daniel Xiang*

#### Theoretical Computer Science

* [Foundations of Computer Science](http://infolab.stanford.edu/~ullman/focs.html) by [*Alfred V. Aho*](https://en.wikipedia.org/wiki/Alfred_Aho) and [*Jeffrey D. Ullman*](https://en.wikipedia.org/wiki/Jeffrey_Ullman)
* [Introduction to Theoretical Computer Science](https://introtcs.org) by [*Boaz Barak*](https://en.wikipedia.org/wiki/Boaz_Barak)

### Multithreading and Concurrency

* [Is Parallel Programming Hard, And, If So, What Can You Do About It?](https://mirrors.edge.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html) by *Paul E. McKenney*
* [POSIX Threads Programming](https://hpc-tutorials.llnl.gov/posix) by *Blaise Barney*
* [The Little Book of Semaphores](https://greenteapress.com/wp/semaphores) by *Allen B. Downey*

### Operating Systems

* [Linux Insides](https://0xax.gitbooks.io/linux-insides/content/) by *0xAD*
* [Making our own executable packer](https://fasterthanli.me/series/making-our-own-executable-packer) by *Amos*
* [Operating Systems: Three Easy Pieces](https://pages.cs.wisc.edu/~remzi/OSTEP/) by *Remzi H Arpaci-Dusseau* and *Andrea C Arpaci-Dusseau*
* [Systems Programming: Lecture Notes](http://web.eecs.utk.edu/~huangj/cs360/lecture_notes.html) by *Jian Huang*
* [The Linux Documentation Project](https://tldp.org)
* [Writing a Simple Operating System — from Scratch](https://www.cs.bham.ac.uk/~exr/lectures/opsys/10_11/lectures/os-dev.pdf) by *Nick Blundell*
* [Writing an OS in Rust](https://os.phil-opp.com) by *Philipp Oppermann*

### Physics

* [A free introduction to quantum computing and quantum mechanics](https://quantum.country) by *Andy Matuschak and Michael Nielsen*
* [Motion Mountain](https://www.motionmountain.net) by *Christoph Schiller* - A free physics textbook in 5 volumes.
* [Relativity: A Modern Primer](http://ramp-book.com) by *Kevin Han*
* [Structure and Interpretation of Classical Mechanics](https://mitpress.mit.edu/sites/default/files/titles/content/sicm_edition_2/book.html), Second Edition by [*Gerald Jay Sussman*](https://en.wikipedia.org/wiki/Gerald_Jay_Sussman) *and* [*Jack Wisdom*](https://en.wikipedia.org/wiki/Jack_Wisdom)
* [The Feynman Lectures on Physics](https://www.feynmanlectures.caltech.edu)

### Programming languages

#### Assembly

* [A fundamental introduction to x86 assembly programming](https://www.nayuki.io/page/a-fundamental-introduction-to-x86-assembly-programming) by *Nayuki*
* [Learn Assembly Language](https://asmtutor.com) - NASM x86 assembly language tutorial on Linux.
* **Let's Learn x86-64 Assembly!**
  * [Part 0 - Setup and First Steps](https://gpfault.net/posts/asm-tut-0.txt.html)
  * [Part 1 - Metaprogramming in Flat Assembler](https://gpfault.net/posts/asm-tut-1.txt.html)
  * [Part 2 - We're Writing a Virtual Machine](https://gpfault.net/posts/asm-tut-2.txt.html)
  * [Part 3 - Arithmetic and Logic](https://gpfault.net/posts/asm-tut-3.txt.html)
* [NASM Tutorial](https://cs.lmu.edu/~ray/notes/nasmtutorial)

#### Basic

* [BBC BASIC for SDL 2.0](https://www.bbcbasic.co.uk/bbcsdl/index.html)

#### C

* [Coroutines in C](https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html) by *Simon Tatham*
* [How Does a C Debugger Work?](https://blog.0x972.info/?d=2014/11/13/10/40/50-how-does-a-debugger-work)
* [The Lost Art of Structure Packing](http://www.catb.org/esr/structure-packing) by *Eric S. Raymond*
* [Unicode programming, with examples](https://begriffs.com/posts/2019-05-23-unicode-icu.html) by *Joe Nelson*

#### C++

* [Awesome Modern C++](https://awesomecpp.com/)
* [Beginner's Guide to Linkers](https://www.lurklurk.org/linkers/linkers.html) by *David Drysdale*
* [Hacking C++](https://hackingcpp.com)
* [C++20 Coroutines: sketching a minimal async framework](https://www.jeremyong.com/cpp/2021/01/04/cpp20-coroutines-a-minimal-async-framework) by *Jeremy Ong*
* [C++20 Concepts: The Definitive Guide](https://thecodepad.com/cpp/c20-concepts-the-definitive-guide) by *Rajat Jain*
* [C++ exceptions under the hood](https://monkeywritescode.blogspot.com/p/c-exceptions-under-hood.html) by *Nicolás Brailovsky*
* [Microsoft C++ language documentation](https://docs.microsoft.com/en-us/cpp/cpp)
* [Performance Analysis and Tunning on Modern CPUs](https://book.easyperf.net/perf_book) by *Denis Bakhvalov*

#### Clojure

* [Clojure Concurrency Tutorial](https://purelyfunctional.tv/guide/clojure-concurrency) by *Eric Normand*
* [Clojure for the Brave and True](https://www.braveclojure.com/) by *Daniel Higginbotham*

#### Common Lisp

* [Practical Common Lisp](https://gigamonkeys.com/book) by *Peter Seibel*
* [The Common Lisp Cookbook](https://lispcookbook.github.io/cl-cookbook)

#### D

* [Programming in D](http://ddili.org/ders/d.en/index.html) by *Ali Çehreli*

#### Erlang

* [Learn You Some Erlang for great good!](https://learnyousomeerlang.com) by *Fred Hebert*

#### Go

* [Network Programming with Go](https://ipfs.io/ipfs/QmfYeDhGH9bZzihBUDEQbCbTc5k5FZKURMUoUvfmc27BwL/index.html) by *Jan Newmarch*
* [Practical Go Lessons](https://www.practical-go-lessons.com) by *Maximilien Andile*

#### Haskell

* [Learn You a Haskell for Great Good!](http://learnyouahaskell.com) by *Miran Lipovača*
* [Monday Morning Haskell](https://mmhaskell.com)
* [Real World Haskell](http://book.realworldhaskell.org) by *Bryan O'Sullivan, Don Stewart, and John Goerzen*

#### JavaScript

* [Eloquent JavaScript](https://eloquentjavascript.net) by *Marijn Haverbeke*
* [The Modern JavaScript Tutorial](https://javascript.info) by *Ilya Kantor*

#### Nim

* [Computer Programming with the Nim Programming Language](https://ssalewski.de/nimprogramming.html) by *Dr. Stefan Salewski*

#### OCaml

* [Real World OCaml](https://dev.realworldocaml.org) by *Yaron Minsky*, *Anil Madhavapeddy* and *Jason Hickey*

#### Pascal

* [Modern Object Pascal Introduction for Programmers](https://castle-engine.io/modern_pascal_introduction.html) by *Michalis Kamburelis*

#### Pyret

* [Programming and Programming Languages](https://papl.cs.brown.edu/2020)

#### Python

* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/2e) by *Al Sweigart*
* [Composing Programs](http://composingprograms.com) by *John DeNero*
* [Learn Python the Right Way](https://learnpythontherightway.com)
* [Scientific Visualization: Python + Matplotlib](https://github.com/rougier/scientific-visualization-book) by *Nicolas Rougier*

#### Racket

* [Beautiful Racket](https://beautifulracket.com/) by *Matthew Butterick*
* [How to Design Programs](https://htdp.org/), Second Edition by *Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi*

#### Regular expressions

* [Implementing Regular Expressions](https://swtch.com/~rsc/regexp) by *Russ Cox*
* [Learn RegEx step by step, from zero to advanced](https://regexlearn.com/)
* [RegexOne](https://regexone.com)
* [Regular-Expressions.info](https://www.regular-expressions.info) by *Jan Goyvaerts*
* [Rex Eats Regular Expressions for Breakfast](https://www.rexegg.com)

#### Rust

* [A Gentle Introduction to Rust](https://stevedonovan.github.io/rust-gentle-intro/readme.html) by *Steve Donovan*
* [Exploring ways to make async Rust easier](https://carllerche.com/2021/06/17/six-ways-to-make-async-rust-easier) by *Carl Lerche*
* [Rust Language Cheat Sheet](https://cheats.rs)
* [Things you can’t do in Rust (and what to do instead)](https://blog.logrocket.com/what-you-cant-do-in-rust-and-what-to-do-instead)

#### Scheme

* [Structure and Interpretation of Computer Programs](https://xuanji.appspot.com/isicp/index.html) by *Harold Abelson and Gerald Jay Sussman with Julie Sussman*

### Retrocomputing

* [An Afterlife User's Guide to the C64](http://www.c64os.com/c64os/afterlifeguide) by *Gregorio Naçu*
* [Famicom Party: Making NES Games in Assembly](https://famicom.party/book) by *Kevin Zurawel*
* [First Steps in Z80 Assembly Language](http://ped.7gods.org/z80.pdf) by *Darryl Sloan*
* [How to Write ZX Spectrum Games](https://spectrumcomputing.co.uk/zxdb/sinclair/entries/2001501/HowToWriteSpectrumGames%28v1.0%29.pdf) by *Jonathan Cauldwell*
* [Learn Multiplatform Assembly Programming](https://www.chibiakumas.com) by *ChibiAkumas*
* [The Lost Ways of Programming: Commodore 64 BASIC](http://tomasp.net/commodore64) by *Tomas Petricek*
* [Z80 User's Manual](https://zany80.github.io/documentation/Z80/UserManual.html)

### Reverse engineering

* [Reverse Engineering for Beginners](https://beginners.re) by *Dennis Yurichev*
* [Reversing for dummies - x86 assembly and C code](https://0x41.cf/reversing/2021/07/21/reversing-x86-and-c-code-for-beginners.html) by *Sami Alaoui*
* [Linux Reverse Engineering CTFs for Beginners](https://osandamalith.com/2019/02/11/linux-reverse-engineering-ctfs-for-beginners)

### Robotics

* [Modern Robotics: Mechanics, Planning, and Control](http://hades.mech.northwestern.edu/index.php/Modern_Robotics) by *Kevin M. Lynch* and *Frank C. Park*
* [Underactuated Robotics](https://underactuated.mit.edu/) by *Russ Tedrake*

### Text editors

* [Build Your Own Text Editor](https://viewsourcecode.org/snaptoken/kilo)
* [Learn Vim (the Smart Way)](https://github.com/iggredible/Learn-Vim) by *Igor Irianto*
* [The Vi/Ex Editor](https://www.ele.uri.edu/faculty/vetter/Other-stuff/vi/009-index.html) by *Walter Alan Zintz*
* [Vim Reference Guide](https://learnbyexample.github.io/vim_reference) by *Sundeep Agarwal*

### Version control tools

* [Git from the Bottom Up](https://jwiegley.github.io/git-from-the-bottom-up) by *John Wiegley*
* [Learn the workings of Git, not just the commands](https://developer.ibm.com/tutorials/d-learn-workings-git) by *Andre Fachat*

### Emulators and Virtual Machines

* [Write your Own Virtual Machine](https://justinmeiners.github.io/lc3-vm)
* [Writing NES emulator in Rust](https://bugzmanov.github.io/nes_ebook) by *Rafael Bagmanov*

### Web programming

* [Intro to Web Dev](https://btholt.github.io/intro-to-web-dev-v2)
* [FastCGI — The Forgotten Treasure](http://www.nongnu.org/fastcgi) by *Peter Simons and Ralph Babel*

### Other

* [Beej's Guides](http://beej.us/guide)
* [Computer Science from the Bottom Up](https://www.bottomupcs.com/) by *Ian Wienand*
* [How These Things Work](https://reasonablypolymorphic.com/book/preface.html) - a book about abstraction
* [Memory Management Reference](https://www.memorymanagement.org)
* [Teach Yourself Computer Science](https://teachyourselfcs.com/)