Comprehensive guide on implementing new field types in the Glazed framework.

A comprehensive guide on how to build custom processors using the provided middleware and types system in Glazed.

Load one or more config files with clear precedence and traceable parse steps

Define layered config discovery as explicit source plans and preserve config provenance in parsed field history, either by resolving files yourself or by loading plans directly through source middlewares.

Learn how to write clear, engaging, and comprehensive documentation for Go-Go-Golems libraries and tools

Build commands with both human-readable and structured output

Use `glaze render-site` to export the Glazed help browser as a static site that can be previewed locally or hosted without a Go server.

Use `glaze help export` to export help section metadata and content to JSON, CSV, files, or SQLite for backup, indexing, and external tooling.

Flag groups are a way to group flags together in the help system. This is useful if you have a lot of flags that are related to each other.

Enforce Glazed CLI command conventions with the custom go vet analyzer.

Understanding how to load Glazed commands dynamically from various sources.

Complete guide to understanding and working with command field sections in Glazed

Complete reference for creating, configuring, and running commands in Glazed

Learn how to use Glazed's middleware system to load field values from various sources

Glazed provides a powerful, queryable help system for creating rich CLI documentation with sections, metadata, and programmatic access.

Style guide and best practices for creating clear, consistent, and helpful documentation.

How to wire profiles.yaml into a Cobra CLI using Glazed middlewares (including proper profile-selection resolution).

Explains how to load fields from a JSON file.

Understand logcopter areas, generated package loggers, Glazed integration, and shared logging profiles.

Comprehensive logging configuration for CLI applications

This document explains the API and usage of the Markdown and Code parsing features in the application.

glazed help system output style can be configured.

Learn how to define and parse fields in Go applications using the Field API.

Declarative mapping of config files to field sections using pattern matching rules

Use profiles.yaml to apply named configuration bundles across field sections, with predictable precedence and debugging.

Learn how to use sections and values in Glazed to organize and manage field definitions.

Use `glaze serve` to browse help exported from other Glazed binaries, JSON files, SQLite snapshots, and markdown directories.

Use `glaze serve` to browse help pages in a browser, and reuse the help API and SPA handlers in your own HTTP server.

Glazed supports a wide variety of table output formats. Besides HTML and Markdown, it leverages the go-pretty library to provide a rich set of styled terminal output.

Create commands that render Go template text using command-line flags and arguments as template variables.

Use go templates to customize output

Guide to using the Glazed templating package.

Explains how command argument usage is indicated within our application.

Learn how to use the GatherFlagsFromStringList function for parsing command line flags programmatically. This function does not require the use of cobra bindings, but instead just requires a list of strings.

A comprehensive guide to using Glazed commands within Lua scripts through the Glazed Lua wrapper

Learn how to use the MultiLoader to handle different types of command files with type-based dispatch

Describes how to work with file inputs in command fields.

Learn how to create and structure Markdown documents for the Glazed help system

A comprehensive guide on writing YAML files to define glazed commands

``` glaze yaml misc/test-data/test.yaml --input-is-array \ --add-fields name:Hello ```

``` glaze json misc/test-data/[123].json --template '{{.a}}-{{.b}}: {{.d_f}}' \ --use-row-templates --fields a,_0 \ --output csv ```

``` glaze yaml misc/test-data/test.yaml \ --input-is-array --rename baz:blop \ --create-cliopatra | tee /tmp/yaml-rename.yaml ```

Use `config.Plan` with either `sources.FromResolvedFiles(...)` or `sources.FromConfigPlan(...)` to build layered config loading with provenance.

This document provides examples of how to use the pagination flags 'glazed-skip' and 'glazed-limit' in Glazed.

``` glaze json misc/test-data/sample.json --input-is-array --regex-fields "^name_.*" --regex-filters ".*_last

``` glaze csv misc/test-data/employees.csv --output csv \ --output-file /tmp/employee.csv --output-multiple-files ```

``` glaze json misc/test-data/duplicates.json --input-is-array --remove-duplicates a,b,c --fields a,b,c ```

``` glaze yaml misc/test-data/test.yaml --input-is-array \ --rename-yaml misc/rename.yaml ```

``` glaze yaml misc/test-data/test.yaml --input-is-array --rename baz:blop ```

``` glaze yaml misc/test-data/test.yaml --input-is-array \ --rename-regexp '^(.*)bar:${1}blop' ```

``` glaze yaml --sanitize misc/broken.yaml --output yaml ```

``` glaze json misc/test-data/[123].json --select-template '{{.a}}-{{.b}}' ```

``` glaze help json --examples ```

``` glaze help --list ```

``` glaze json misc/test-data/sort.json --input-is-array --sort-by city,-name ```

``` glaze json misc/test-data/[123].json \ --template-field 'foo:{{.a}}-{{.b}},bar:{{.d_f}}' \ --use-row-templates --fields a,foo,bar ```

Learn how to use the flags that control SQL output in the `glaze` program.

``` glaze json misc/test-data/[123].json --template '{{.a}}-{{.b}}: {{.d.f}}' ```

``` glaze json misc/test-data/[123].json --jq '.select(.a > 10) // []' ```

``` glaze json misc/test-data/[123].json --jq '.b = .c' ```

A comprehensive application example for managing user records using Glazed commands.

Placeholder for what will be a small application overview of what can be done by reading from SQLite

Shows different ways glaze can be used to iterate over columns with a shell script

Generate package loggers and configure area-specific levels through Glazed logging settings.

Quick hands-on tutorial to build, run, and use a Glazed command with structured output

Minimal examples to load single and multiple config files with clear precedence

A step-by-step playbook for adopting generated logcopter package loggers in go-go-golems repositories.

A tutorial that shows how to build a small but rich help system for a demo CLI application, with embedded markdown files for additional examples, tutorials and topic pages.

Step-by-step tutorial for creating reusable custom field sections in Glazed

Fetch the versioned `glazed-spa` GitHub Release asset and embed it in another Glazed-based binary.

A step-by-step tutorial for implementing and using the Glazed Lua wrapper in your applications

Step-by-step guide to migrate existing Glazed applications from Viper-based configuration to the new config file middleware system

Exhaustive, no-compat playbook for migrating Glazed code from the legacy layers/parameters API to the schema/fields/values/sources API.