LA
Bundled by Ludwig ABAP

📥  Last added

Saved in the past week and not yet archived (default view)

What's included

Training Large Language Models to Reason in a Continuous Latent Space

A Guide on Semiconductor Development

Recommended Books and Resources

The Computer as a Communication Device

ARM's Chernobyl Moment

The Uses of Complacency

The Book of Shaders

Unstructured Thoughts on the Problems of OSS/FOSS

On Bloat

Training Large Language Models to Reason in a Continuous Latent Space

On the Biology of a Large Language Model

Do Llamas Work in English? On the Latent Language of Multilingual Transformers

The Unsustainability of Moore’s Law

The Era of Experience Paper

"Does Reinforcement Learning Really Incentivize Reasoning Capacity in LLMs Beyond the Base Model?"

+33 7 80 61 21 67

tt-metal/tech_reports/memory/allocator.md at main · tenstorrent/tt-metal

What Modern NVMe Storage Can Do, And How To Exploit It: High-Performance I/O for High-Performance Storage Engines

Memory on Tenstorrent

Multi-layer language heads: the output latent is for text (and nothing else)

Subnanosecond flash memory enabled by 2D-enhanced hot-carrier injection

Andrew_S._Tanenbaum_-_Structured_Computer_Organization

CS336: Language Modeling from Scratch

A Gentle Introduction to Lambda Calculus - Part 1: Syntax

Getting Started

curry-howard.dvi

Intelligence as efficient model building

Contextualization Machines

What Is ChatGPT Doing … and Why Does It Work?

Mission Apollo: Landing Optical Circuit Switching at Datacenter Scale

The Illustrated Transformer

Driven by Compression Progress: A Simple Principle Explains Essential Aspects of Subjective Beauty, Novelty, Surprise, Interestingness, Attention, Curiosity, Creativity, Art, Science, Music, Jokes

Position: Model Collapse Does Not Mean What You Think

paper

88_HC2024.Tenstorrent.Jasmina.Davor.v7

RWKV Language Model

Recent AI model progress feels mostly like

Device Placement Optimization with Reinforcement Learning

Building an Open Future

diffusion transofrmers

diffusion transformers

Faking ADTs and GADTs in Languages That Shouldn't Have Them

Accelerate

Ok Rust, You Really Have a Readability Problem

Circuit Tracing: Revealing Computational Graphs in Language Models

Things that go wrong with disk IO

Analyzing Modern NVIDIA GPU cores

tt-metal/tech_reports/AdvancedPerformanceOptimizationsForModels/AdvancedPerformanceOptimizationsForModels.md at main · tenstorrent/tt-metal · GitHub

paper.dvi

þÿKevin-and-Nick.PDF

Move Slow and Fix Things

Why is Yazi fast?

User Guide for NVPTX Back-end

An AnandTech Interview with Jim Keller: 'The Laziest Person at Tesla'

Notes/Primer on Clang Compiler Frontend (1) : Introduction and Architecture

Implementation of simple microprocessor using verilog

learn-fpga/FemtoRV/TUTORIALS/FROM_BLINKER_TO_RISCV/README.md at master · BrunoLevy/learn-fpga · GitHub

Why async Rust?

Softmax Attention is a Fluke

Transformers Laid Out

Template Haskell

A friendly introduction to machine learning compilers and optimizers

Comments on Source

The_Implementation_of_Lua_5.0

Bloom’s 3 Stages of Talent Development

introduction-to-algorithms-and-machine-learning

justinmath-linearAlgebra

Russell’s Paradox and Possible Solutions

The Making of Python

Advice on Upskilling

tt-metal/METALIUM_GUIDE.md at main · tenstorrent/tt-metal · GitHub

Scoping out the Tenstorrent Wormhole

What’s the (floating) Point of all these data types? A (not so) brief overview of the history and usage of datatypes within the wide world of computation

Physics of language models

Tenstorrent first thoughts

7 x 11.5 long title.p65

Neural Networks, Manifolds, and Topology

Attention from Beginners Point of View

(How) Do Language Models Track State?

Why Attention Is All You NeedWhy Attention Is All You Need

CFD Python: 12 steps to Navier-Stokes

tt-mlir documentation

Tutorials

Yizhou Shan's Home Page

Attention in SRAM on Tenstorrent Grayskull

Crossing the uncanny valley ofconversational voice

Project 3: Distributed File System

By John Taylor Gatto

How to Think About TPUs

Programming Really Is Simple Mathematics

Tenstorrent Wormhole Series Part 1: Physicalities

Community Highlight: Tenstorrent Wormhole Series Part 2: Which disabled rows?

Execution-based Code Generation using Deep Reinforcement Learning

þÿThe Impact of Generative AI on Critical Thinking: Self-Reported Reductions in Cognitive Effort and Confidence Effects From a Survey of Knowledge Workers

neural video codecs: the future of video compression

Lego Mindset vs. Woodworking Mindset

Gestalt Programming: A New Concept in Automatic Programming

Mastering LLM Techniques: Evaluation

Mastering LLM Inference Techniques: Inference Optimization

Automating GPU Kernel Generation with DeepSeek-R1 and Inference Time Scaling

The high-return activity of raising others’ aspirations

Build Your Own Text Editor

The What, Why, and How of Context Length Extension Techniques in Large Language Models -- A Detailed Survey

Tilde, my LLVM alternative

A WebAssembly compiler that fits in a tweet

Transformer Memory as a Differentiable Search Index

history.dvi

Proof of correctness of data representation

Unnamed Document

Elements of Programming

Unveiling_DeepSeek.pdf

Stating the problem in Lean

DeepSeek-V3 Explained: A Deep Dive into the Next-Generation AI Model

Foundations of Large Language Models

þÿA comprehensive study of Convergent and Commutative Replicated Data Types

hist

þÿPart II - Algebraic Topology (Theorems with proof)

fundamental-group

Category Theory: Lecture Notes and Online Books

Why Futhark?

Algorithms for Modern Hardware

DeepSeek-V3 Technical Report

Linkers part 1

gcvsmalloc

``You and Your Research''

Bloom filters debunked: Dispelling 30 Years of bad math with Coq!

DeepSeek-V3/DeepSeek_V3.pdf at main · deepseek-ai/DeepSeek-V3

by Marcus Hutter and David Quarel and Elliot Catt

Deepseek: The Quiet Giant Leading China’s AI Race

The Double-E Infix Expression Parsing Method

(26) Demystifying Debuggers, Part 2: The Anatomy Of A Running Program Demystifying Debuggers, Part 2: The Anatomy Of A Running Program

Towards a Categorical Foundation of Deep Learning: A Survey

Soft question: Deep learning and higher categories

Algebraic Databases

Categorical Databases

walter

FPGAs for Software Engineers 0: The Basics

Data-Oriented Design

A note about "The Humane Representation of Thought"

BLT__Patches_Scale_Better_Than_Tokens

On Ousterhout’s Dichotomy Oct 6, 2024

The categorical abstract machine

Position: Categorical Deep Learning is an Algebraic Theory of All Architectures

Fundamental Components of Deep Learning: A category-theoretic approach

Logic and linear algebra: an introduction

Gemini: A Family of Highly Capable Multimodal Models

Flow Matching Guide and Code

Logical Complexity of Proofs

Mastering Board Games by External and Internal Planning with Language Models

Proofs and Types

Richard Hamming - Wikipedia

What is the "question" that programming language theory is trying to answer?

Introducing Limbo: A complete rewrite of SQLite in Rust

TLA+ is hard to learn

How hard is constraint programming?

Fundamental Components of Deep Learning: A category-theoretic approach

Geeks, MOPs, and sociopaths in subculture evolution

Advanced programming languages

ugh.book

Working memory - Wikipedia

Working hurts less than procrastinating, we fear the twinge of starting

llama.cpp guide - Running LLMs locally, on any hardware, from scratch

GitHub - avinassh/py-caskdb: (educational) build your own disk based KV store

Depth-First Procrastination

Command Line Interface Guidelines

How Many Computers Are In Your Computer?

Category theory for scientists (Old version)

Genie 2: A large-scale foundation world model

Design Of This Website

WilliamYi96/Awesome-Energy-Based-Models: A curated list of resources on energy-based models.

"CBLL, Research Projects, Computational and Biological Learning Lab, Courant Institute, NYU"

yataobian/awesome-ebm: Collecting research materials on EBM/EBL (Energy Based Models, Energy Based Learning)

TuringConf

Omens of exceptional talent

An Introduction to Current Theories of Consciousness

Being the (Pareto) Best in the World

Greg Yang

Some questions

A Century of Mathematics in America, Part I

Fastest contributed programs, grouped by programming language implementation

Haskell as fast as C: working at a high altitude for low level performance

On Competing with C Using Haskell

Performance

TS_Tutorial

Category Theory usage in Algebraic Topology

Topos Theory in a Nutshell

context

Proof Explorer

An Invitation to Applied Category Theory

An Invitation to Applied Category Theory

Introducing io_uring_spawn

Information Theory: A Tutorial Introduction

Daniel Lemire's blog

A Beginner's Guide to Vectorization By Hand: Part 3

Noghartt's garden

Competitive Programming

My favorite books

MOND←TECH MAGAZINE

Coalescence: making LLM inference 5x faster

þÿClassics in the History of Psychology -- Miller (1956)

Creating enums at comptime

Zig's new declaration literals

Zig's (.{}){} syntax

How to get from high school math to cutting-edge ML/AI: a detailed 4-stage roadmap with links to the best learning resources that I’m aware of.

Fundamental Components of Deep Learning: A category-theoretic approach

How LLVM Optimizes a Function

PS2_and_PC_BIOS_Interface_Technical_Reference_Apr87

How 99% of C Tutorials Get it Wrong

A Beginner's Guide to Vectorization By Hand: Part 1

Tell the Compiler What You Know

Compiler Optimization in a Language you Can Understand

How Target-Independent is Your IR?

Bibliopolis-Book-retypeset-1984

Numerical Recipes

Unpacking Intuition

For Beginners

Oasis: A Universe in a Transformer

A Fat Pointer Library

The Basics

TCP Server in Zig - Part 5a - Poll

(8810) YouTube

6.824 Schedule: Spring 2022

2305.20091

Humans in 4D: Reconstructing and Tracking Humans with Transformers

slpj-book-1987.djvu

Typing the technical interview

Reversing the technical interview

Hexing the technical interview

Nine Rules for SIMD Acceleration of Your Rust Code (Part 1)

Conscious exotica

B-trees and database indexes

Safe C++

Tutorial on Diffusion Models for Imaging and Vision

Async Rust can be a pleasure to work with (without `Send + Sync + 'static`)

The Perfect Plan

The Fast Track

Zig's BoundedArray

Linus Torvalds talks AI, Rust adoption, and why the Linux kernel is 'the only thing that matters'

Intercepting and modifying Linux system calls with ptrace

What's the big deal about Deterministic Simulation Testing?

Zig and Emulators

A ToC of the 20 part linker essay

trading_interview_blog

`zig cc`: a Powerful Drop-In Replacement for GCC/Clang

Zig Build System

Resources for Amateur Compiler Writers

MattPD/cpplinks: A categorized list of C++ resources.

Putting the “You” in CPU

How to Compile Your Language

Introduction to the Odin Programming Language

Arena allocator tips and tricks

No Starch Press

Part 2: Portable Executable Files

bytecode interpreters for tiny computers

How I built zig-sqlite

The Hunt for the Missing Data Type

Microfeatures I'd like to see in more languages

Google’s Fully Homomorphic Encryption Compiler — A Primer

Will I be able to access proprietary platform APIs (e.g. Android / iOS)?

The future of Clang-based tooling

Fast Multidimensional Matrix Multiplication on CPU from Scratch

Efficient n-states on x86 systems

Program tuning as a resource allocation problem

How web bloat impacts users with slow connections

Files are hard

Ringing in a new asynchronous I/O API

applicative-mental-models

applicative-mental-models

Optimizing subroutines in assembly language

Brian Robert Callahan

QBE vs LLVM

Recent presentations and papers

brotli-2015-09-22

How long does it take to make a context switch?

Ghostty Devlog 001

Tiled Matrix Multiplication

Rust Atomics and Locks

Compiler Backend

Vale's Memory Safety Strategy: Generational References and Regions

Introduction

Cache-Oblivious Algorithms

A Memory Allocator

Cramming: Training a Language Model on a Single GPU in One Day

The MiniPile Challenge for Data-Efficient Language Models

Stretching Each Dollar: Diffusion Training from Scratch on a Micro-Budget

1024cores

Implementing interactive languages

Pointers Are Complicated, or: What's in a Byte?

Three Architectures for a Responsive IDE

How a Zig IDE Could Work Feb 10, 2023

Properly Testing Concurrent Data Structures Jul 5, 2024

Parse, don’t validate

Too Fast, Too Megamorphic: what influences method call performance in Java?

The Black Magic of (Java) Method Dispatch

Why null sucks, even if it's checked

Unnamed Document

Resources for Building Programming Languages

Little 'Big Ideas' in Programming Language Design

Computer Networking: A Top-Down Approach

Using Uninitialized Memory for Fun and Profit Posted on Friday, March 14, 2008.

Zip Files All The Way Down

UTF-8: Bits, Bytes, and Benefits Posted on Friday, March 5, 2010.

Minimal Boolean Formulas

Hacking the OS X Kernel for Fun and Profiles Posted on Tuesday, August 13, 2013.

How To Build a User-Level CPU Profiler Posted on Thursday, August 8, 2013.

An Encoded Tree Traversal

Our Software Dependency Problem

The Magic of Sampling, and its Limitations Posted on Saturday, February 4, 2023.

Running the “Reflections on Trusting Trust” Compiler Posted on Wednesday, October 25, 2023.

Improving the Font Pipeline

Easy Scalable Text Rendering on the GPU

Adventures in Text Rendering: Kerning and Glyph Atlases

Exploring the Power of Negative Space Programming

CompilerTalkFinal

Graydon Hoare: 21 compilers and 3 orders of magnitude in 60 minutes

p75-hoare

Updating the Go Memory Model

Programming Language Memory Models (Memory Models, Part 2) Posted on Tuesday, July 6, 2021. PDF

Hardware Memory Models (Memory Models, Part 1) Posted on Tuesday, June 29, 2021. PDF

Baby Steps to a C Compiler

Kernel Programming Guide

Tiny Tapeout

Why Pascal is Not My Favorite Programming Language

What Color is Your Function?

What is an Invariant? Oct 6, 2023

Chess-GPT's Internal World Model

Emergent World Models and Latent Variable Estimation in Chess-Playing Language Models

Manipulating Chess-GPT's World Model

Crafting an Interpreter in Zig - part 1

Teach Yourself Programming in Ten Years

What Every Computer Scientist Should Know About Floating-Point Arithmetic

The Development of the C Language*

Class Warfare

Ownership

A Note About Zig Books for the Zig Community

Your Starting Point!

Zig Interfaces for the Uninitiated, an update

Zig Interfaces for the Uninitiated

Exploring Compile-Time Interfaces in Zig

Aro - a C compiler

Do you want to learn how databases really work?

Database Systems

Discovering and exploring mmap using Go

But how, exactly, databases use mmap?

reHow memory mapped files, filesystems and cloud storage works

Implementing a file pager in Zig

Criticizing Hare language approach for generic data structures

spikedoanz/from-bits-to-intelligence: machine learninig stack in under 100,000 lines of code

One year of C

Heap Memory and Allocators

Pointers

Learning Zig - Pointers

Emulator 101

Data Compression Explained

Twitter's Recommendation Algorithm

Programming languages resources

3D Math Primer for Graphics and Game Development

Welcome to OpenGL

WebGPU Fundamentals

An opinionated beginner’s guide to Haskell in mid-2019

Are tagged unions overrated?

C++ Core Guidelines

What every systems programmer should know about concurrency

compiler_construction

How do we tell truths that might hurt?

The next fifty years

Recommender Systems: A Primer

http client in the standard library · Issue #2007 · ziglang/zig

Introduction to Compilers and Language Design

Bare Metal Zig

Comparing SIMD on x86-64 and arm64

Compiler Optimizations Are Hard Because They Forget

C Isn't A Programming Language Anymore

Writing a C Compiler, Part 1

GitHub - DoctorWkt/acwj: A Compiler Writing Journey

A new JIT engine for PHP-8.4/9

Unknown

Introduction 2016 NUMA Deep Dive Series

von Neumann architecture - Wikipedia

Compiling tree transforms to operate on packed representations

Pipelines Support Vectorized, Point-Free, and Imperative Style

Entering text in the terminal is complicated

What happens when you start a process on Linux?

Debug your programs like they're closed source!

How I got better at debugging

Media Page Under Construction

Infographics: Operation Costs in CPU Clock Cycles

Handles are the better pointers

You're Not Sick of Programming

Zig Bare Metal Programming on STM32F103 — Booting up

OWASP Top Ten

Introduction

The Copenhagen Book

Undefined Behavior deserves a better reputation

KHM+15

Learning LLVM (Part-1) - Writing a simple LLVM pass

Some Were Meant for C

Xv6, a simple Unix-like teaching operating system

C Is Not a Low-level Language

Should you learn C to "learn how the computer works"?

A Guide to Undefined Behavior in C and C++, Part 1

Using neural nets to recognize handwritten digits

When Network is Faster than Cache

John Carmack on Functional Programming in C++

Zig-style generics are not well-suited for most languages

WebGL2 vs WebGL1

WebGL How It Works

The_Night_Watch

FreeType

A Freestanding Rust Binary

Manually linking Rust binaries to support out-of-tree LLVM passes

The Rust Reference

The Rust Borrow Checker - A Deep Dive - Nell Shamrell-Harrington, Microsoft

Rust Compiler Development Guide

How to speed up the Rust compiler one last time

How to speed up the Rust compiler in March 2024

Zig Bits 0x4: Building an HTTP client/server from scratch

Do We Really Need A Link Step?

Death Note: L, Anonymity & Eluding Entropy

jamiebuilds/the-super-tiny-compiler: :snowman: Possibly the smallest compiler ever

5 Days to Virtualization: A Series on Hypervisor Development

In-depth analysis on Valorant’s Guarded Regions

Exploit Development: No Code Execution? No Problem! Living The Age of VBS, HVCI, and Kernel CFG

Reader

CheerpX versus WebContainers

Creating a Rootkit to Learn C

Picsart-AI-Research/LIVE-Layerwise-Image-Vectorization: [CVPR 2022 Oral] Towards Layer-wise Image Vectorization

Udacity CS344: Intro to Parallel Programming

CS 361: Systems Programming

Resolving Rust Symbols

When FFI Function Calls Beat Native C

Cap'n Proto, FlatBuffers, and SBE

A Database Without Dynamic Memory Allocation

Wizard Zines Collection!

Aggregating Millions of Groups Fast in Apache Arrow DataFusion 28.0.0

Problems of C, and how Zig addresses them

How to use hash map contexts to save memory when doing a string table

resume.txt

Leslie Lamport

Indices and tables

448997590_1496256481254967_2304975057370160015_n

I've spent the past ~2 weeks building a GPU from...

Bare Bones

(4928) MIT 6.004 Computation Structures, Spring 2017 - YouTube

The Graphics Codex

[2305.13009] Textually Pretrained Speech Language Models

Notes on partial borrows

Dioxus Labs + “High-level Rust”

Compile-Time Configuration For Zig Libraries

Generics

Zig's HashMap - Part 1

Zig Parser

Copying Better: How To Acquire The Tacit Knowledge of Experts

(4895) IronBeetle with matklad - YouTube

Causal ordering

Assorted thoughts on zig (and rust)

Columnar kernels in go?

An opinionated map of incremental and streaming systems

Internal consistency in streaming systems

Pain we forgot

Have you tried rubbing a database on it?

The shape of data

Reflections on a decade of coding

Prospecting for Hash Functions

The Missing Zig Polymorphism / Runtime Dispatch Reference

Nanosystems

How To Become A Hacker

the rr debugging experience

Text Buffer Reimplementation

What Is The Minimal Set Of Optimizations Needed For Zero-Cost Abstraction?

Using ASCII waveforms to test hardware designs

Rust 2019 and beyond: limits to (some) growth.

Your ABI is Probably Wrong

GitHub - sirupsen/napkin-math: Techniques and numbers for estimating system's performance from first-principles

Don't write bugs

technicalities: "not rocket science" (the story of monotone and bors)

Why is Python slow

Design duality and the expression problem

Random Thoughts On Rust: crates.io And IDEs

John Carmack on Inlined Code

A Few Billion Lines of Code Later: Using Static Analysis to Find Bugs in the Real World

What is Systems Programming, Really?

MLKV: Multi-Layer Key-Value Heads for Memory Efficient Transformer Decoding

Mitchell Hashimoto

Understanding_Machine_Learning_-_From_Theory_to_Algorithms

UB Might Be a Wrong Term for Newer Languages Apr 2, 2023

What Every C Programmer Should Know About Undefined Behavior #1/3

The Rustonomicon

chrono-Compatible Low-Level Date Algorithms

Step-by-Step Diffusion: An Elementary Tutorial

So Many New Systems Programming Languages II

zackoverflow

From Theory To Implementation

Speech-to-text models

Ray Tracing in One Weekend

Untangling Lifetimes: The Arena Allocator

Tree-Structured Concurrency — 2023-07-01

immersivemath: Immersive Linear Algebra

BSTJ 57: 6. July-August 1978: The UNIX Time-Sharing System. (Ritchie, D.M.; Thompson, K.)

Principles of compiler design