# 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/)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.exohood.com/resources/open-library.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.