1. Core primitives | ag_tensor and ag_param | Forward pass and gradient tape | 2. Built-in operations | 3. ag_sequential — module API | 4. Optimizers | Training loop | 5. LR schedulers | 6. Gradient clipping | 7. Dataloader | 8. Eval mode and inference | 9. Raw ag_param — full manual control | 10. Mixed precision | 11. GPU residency | Two rules this imposes | Switching it off | Device buffers | 12. Data-parallel training

Installation | 1. Sequential API | 1.1 Prepare data — iris (3-class classification) | 1.2 Build and compile | 1.3 Train | 1.4 Evaluate and predict | 1.5 Save and reload | 2. Functional API | 2.1 Single-input DAG — residual-style network on iris | 2.2 Multi-input model — mtcars regression | 2.3 Multi-output model — one trunk, two heads | 2.4 Attention and a transformer block | 3. Callbacks | 3.1 Early stopping | 3.2 Learning-rate schedulers | 4. Autograd Engine (ag_*) | 4.1 Prepare data (iris, col-major) | 4.2 Build a model with ag_sequential | 4.3 Training loop | 4.4 Inference and accuracy | 4.5 LR scheduler + gradient clipping | 4.6 Manual model from raw ag_param | 5. GPU / device selection | API summary

1. Check availability | 2. Device enumeration | 3. Autograd device selection | 4. Mixed precision (f16 / bf16) | 5. Vulkan memory info | 6. Multi-GPU | 7. Sequential / functional API on GPU | 8. ONNX inference on GPU | 9. Build configuration | Restoring the default device

1. Concept | 2. Minimal example | 3. Multi-GPU | 4. Gradient clipping | 5. ag_dataloader — batched training loop | 6. Full example

1. Landmark states | Rotations are free | 2. Distances | Why not human_algorithm() | 3. Picking six pairs | 4. Where a landmark sits | 5. The solid | Results | What this does and does not establish | Running it

Basic Permutation Operations (C++) | shift_left(state, coords = NULL) | shift_right(state, coords = NULL) | reverse_prefix(state, k, coords = NULL) | shift_left_simple(state) | shift_right_simple(state) | reverse_prefix_simple(state, k) | apply_operations(state, operations, k, coords = NULL, compute_coords = TRUE) | openmp_threads() | Cycle Analysis | get_reachable_states(start_state, allowed_positions, k, verbose = FALSE) | get_reachable_states_light(start_state, allowed_positions, k) | analyze_top_combinations(top_combos, start_state, k) | Pathfinding | bidirectional_bfs(n, state1, state2, max_level, moves, k) | find_path_iterative(start_state, final_state, k, moves, combo_length, n_samples, n_top, max_iterations, potc, ptr, opd, reuse_combos, keep_states, one_sided, distance_method, sort_by, verbose) | find_path_bfs(start_state, final_state, k, ...) | sparse_bfs(start_state, k, n_hubs, n_random, max_levels) | reconstruct_bfs_path(bfs_result, target_key) | short_path_bfs(path, start_state, k, depth = 5) | cycle_shortcut(path, start_state, k, n_points = 20, moves, combo_length = 20, n_samples = 200, n_top = 5, sort_by, max_cycle_len = 20000, n_threads = NULL, verbose = FALSE) | human_algorithm(start_state, final_state = NULL, k = 4L, simplify = TRUE) | human_algorithm_cpp(start_state, k, max_ops, final_rotate) (internal) | human_algorithm_to(start_state, target_state = NULL, k = 4, simplify = TRUE) | human_phase1_rank(state, k = 4, sorted = TRUE) | human_phase1_navigate(state, k = 4, max_steps = 2000, trace = FALSE) | run_length(state) | find_best_match_human(states, target, k) | Combination Search | find_best_random_combinations(moves, combo_length, n_samples, n_top, start_state, k, sort_by) | Path Utilities | invert_path(path) | short_position(allowed_positions, n) | validate_and_simplify_path(path_candidate, start_state, final_state, k) | State Processing & Distance | calculate_differences(start_state, reachable_states_start, method, use_gpu) | select_unique(df) | check_duplicates(df1, df2) | manhattan_distance(start_state, target_state) | breakpoint_distance(start_state, target_state) | save_bridge_states(bridge_states, filename) | filter_middle_states(data, skip_first, skip_last) (internal) | find_best_match_state(target_state, reachable_states, method, use_gpu) (internal) | select_new_state(target_all, opposite_state, method) (internal) | cayley_distance_methods() | cayley_distance(method) | State Indexing | add_state_keys(states_df, new_states, v_cols) (internal) | create_hash_index(states_df) (internal) | State Store (C++ Backend) | create_state_store(perm_length, init_capacity) | state_store_size(xp) | state_store_unique_count(xp) | state_store_perm_length(xp) | store_add_from_df(store, df, cycle_val) | store_get_state(store, idx) | store_get_meta(store, idx) | store_find_intersections(store_a, store_b) | store_lookup(store, state) | store_find_best_match(store, target, candidate_indices) | store_filter_middle(store, target_cycle, skip_first, skip_last) | store_set_opd(store, target_cycle, combos) | store_clear_opd(store) | store_combos_for_state(store, state, target_cycle) | store_to_dataframe(store) | store_reconstruct_path(store, bridge_states, target_state, target_cycle, target_combo) | store_analyze_combos(store, top_combos, start_state, k, cycle_val) | store_analyze_combos_gpu(store, top_combos, start_state, k, cycle_val) | store_clear(store) | store_collect_ops(store, target_cycle, target_combo, end_step) | state_store_indices_for_cycle(xp, target_cycle) | Graph Metrics | cayley_bfs_full(start_state, k, moves = c("L", "R", "X")) | cayley_graph_diameter(start_state, k, moves, method = c("all_pairs", "from_start"), max_pairs = Inf, verbose = FALSE) | Celestial Coordinates | convert_LRX_to_celestial(nL, nR, nX) | calculate_angular_distance_z(result1, result2) | calculate_midpoint_z(coords1, coords2) | find_closest_to_coords(reachable_states, target_coords, v_cols) | GPU Acceleration (optional, requires ggmlR) | cayley_gpu_available() | cayley_gpu_init(device = 0, force = FALSE) | cayley_gpu_status() | cayley_gpu_free() | apply_operations_batch_gpu(states_matrix, operations, k) | manhattan_distance_matrix_gpu(states1, states2, batch_size = 256) | calculate_differences_gpu(start_state, states_matrix) (internal) | build_permutation_matrix(op, n, k) (internal) | compose_permutation_matrix(operations, n, k) (internal) | Utilities | convert_digits(s) | generate_state(n, k, n_moves, moves, max_attempts) | generate_unique_states_df(n, n_rows) | has_data_table() (internal) | Intersection Processing (internal) | reconstruct_full_path(reachable_states, start_state, target_state, target_cycle, target_combo, v_cols) | process_start_intersection(intersection_state, reachable_states_final, bridge_states_final, final_index, v_cols) | process_final_intersection(intersection_state, reachable_states_start, bridge_states_start, start_index, v_cols) | process_intermediate_intersection(intersection_state, reachable_states_start, reachable_states_final, bridge_states_start, bridge_states_final, start_index, final_index, v_cols) | State Search | find_combination_in_states(reachable_states_start, search_state)

Notation | Phase 1: build 1…12 | Why stop at 12 rather than 16 | Phase 2: sort the eight-tile tail (13…20) | Sequence A | Sequence B | Parity: why it sometimes refuses to finish | Finishing | Differences from the common description | Scope

1. The one rule that matters | 2. Data parallelism: replicas | 3. When the model does not fit: layer vs row | 4. The hybrid: TP × DP | 5. Measuring it yourself | 6. Serving | 7. Summary

The one call: RunGGML() | A worked example | Normalize and scale on the GPU | PCA (embed) | UMAP (umap) | Neighbour graphs (neighbors) | Provenance | The layers underneath | Bioconductor: SingleCellExperiment | A real dataset, end to end | Speed-up | Agreement | What is and isn't accelerated

1. Which mode do you need? | Are you sure you want this layer? | 2. The transport, and why it constrains everything | 3. Tensor parallelism | 4. Pipeline parallelism | 5. Hybrid: DP over TP or PP | 6. Clean shutdown (and the --enable-hard-exit flag) | 7. Where to look next | 8. Summary

1. The chat object: chat_llamar() | Mode A — spawn a server for a model | Mode B — connect to a running server | System prompt | 2. The server: llama_serve_openai() | Connecting OpenCode | 3. The command-line example | 4. ragnar: retrieval-augmented chat | 5. Tool calling: llama_chat_build() / llama_chat_parse() | 6. Claude Code on a local model: llama_serve_anthropic() | 7. Concurrency | See also

Next steps

1. Classification | 2. Regression | 3. Engine parameters | 4. Resampling with rsample | 5. Recipes for preprocessing | 6. Hyperparameter tuning | 7. Comparison with other engines | 8. Extracting the fitted engine and fit time | 9. Limitations of the engine object | Summary

Quick start | Classification | Regression | Learner parameters | GPU acceleration | Custom model architecture | Resampling and benchmarking | Hyperparameter tuning | Callbacks | Observation weights | Marshal and parallel execution | Summary

1. Quantization formats | 2. Quantize and dequantize | 3. K-quants (better quality) | 4. IQ quants — importance matrix | 5. Comparing formats | 6. Reference (row-level) functions

1. Load and inspect a model | 2. Run inference | 3. GPU inference | 4. Dynamic input shapes | 5. FP16 inference | 6. Supported operators | 7. Examples | 8. Debugging tips

Part A — Using the ggmlR R API from your package | A1. Depend on ggmlR | A2. Everything the examples use is exported | A3. tidymodels / mlr3 engines | Part B — Linking ggml from your package's C/C++ code | 1. What ggmlR exports | 2. DESCRIPTION | 3. src/Makevars | 4. configure — detect ggmlR at build time | 5. C code — minimal example | 6. R wrapper | 7. Thread count | 8. Vulkan in downstream packages | 9. Real-world references

1. Getting a model | 2. Loading a model and creating a context | 3. Generating text | 4. Chat models and templates | 5. Tokenization | 6. Embeddings | ragnar-compatible provider | 7. Serving and chatting | See also

Choosing a variant | Performance snapshot | A minimal example of each | Where to go next

Quick start | How it works | Algorithms (type =) | Scope (scope =) | Prefix matching (routes =) | Per-IP limiting | Operational notes

How it works | dr_stream() — the base API | dr_stream_sse() — Server-Sent Events | Threading: keep each pump short | Cancellation contract | Errors inside next_chunk() | Middleware does not wrap individual chunks | Native (C / C++) streaming | Caveats

The handler ABI | A complete example | Threading rule (critical) | Memory ownership cheat-sheet | Where this fits

Building an app | The req object | Building responses | Middleware | Static files | Starting and stopping the server | When to reach for the other variants

The one-line swap | What the shim supports | What the shim rejects | A minimal end-to-end example | When to migrate to native

1. A first graph | 2. Force-directed layout | 3. Highlighting a path | 4. Camera control | 5. Recording a video | 6. Headless mode | Where to next