[opensourcedex]

hof is a free, open source orchestration & scheduling project written in Go and released under Apache-2.0. It has 615 GitHub stars, 48 forks and 74 open issues, and was last pushed 6 months ago. On this registry it ranks #125 of 130 tracked projects in Orchestration & Scheduling, with 5 head-to-head comparisons available. It gained 1 stars over the last 30 tracked days.

What is hof?

hof is an Apache-2.0-licensed, Go-based command-line framework and TUI that unifies CUE schemas, data models, deterministic and agentic code generation, and a DAG task engine into a single developer experience for engineers who want one declarative source of truth across their toolchain.

What it is

hof, short for the higher order framework, is a CLI tool that developers add to an existing workflow rather than a platform they migrate onto. It is built on CUE, the configuration and schema language that comes from the same lineage as containers, Go, and Kubernetes, and it uses CUE as the lattice on which schemas, data models, code generation, workflows, and tasks are all expressed. The project exposes two interfaces: a CLI suited to scripting and automation, and a TUI suited to exploring and designing. It is written in Go, licensed under Apache-2.0, and documented at docs.hofstadter.io.

The problem it addresses is fragmentation. Schema definitions, per-technology code generators, and task runners normally live in separate tools with separate sources of truth, so a change to a data model has to be replicated by hand across every generator and pipeline that consumes it. hof collapses those concerns into one CUE-backed definition: data models can be defined, checkpointed, diffed, and migrated, and those same models then serve as input to code generation, where data plus templates produce output for any technology. The same declarative foundation drives the task and DAG workflow engine, so generation and orchestration share a source of truth instead of being stitched together.

Key capabilities

  • Deterministic and agentic code generation through hof gen, where data plus templates yields technology-agnostic output.
  • Data modeling through hof datamodel, which manages, diffs, and migrates data models that can evolve over time.
  • A task and DAG workflow engine through hof flow, based on cue/flow and described as extensible.
  • Core CUE commands exposed directly: hof def prints consolidated definitions, hof eval evaluates and prints configuration, hof export outputs data in a standard format, and hof vet checks it.
  • hof create bootstraps starter kits and blueprints from any Git repository, while hof mod provides CUE module dependency management.
  • hof chat combines an LLM with hof code generation for better, scalable results, and is explicitly marked alpha.
  • Agent servers and a VS Code extension ship alongside the CLI and TUI, and the framework includes Dagger-powered environments.

Who uses it and how

  • Developers who automate: the CLI is presented as the interface for scripting and automation, and hof create generates starter kits or blueprints from any Git repository.
  • Engineers who explore before they commit: the TUI provides a terminal interface to hof and CUE for designing schemas and data models interactively.
  • Teams whose data models change over time: hof datamodel manages, diffs, and migrates those models while keeping them usable as code generation input.
  • CI and pipeline work: the repository carries a ci/ directory of continuous integration scripts, and contributors build with make build and run the suite with make test.
  • Editor-centric developers: the VS Code extension and agent servers bring the same CUE-backed generation into the editor rather than the terminal.

Getting started

The preferred installation is the latest download from the GitHub releases page, with Homebrew available as brew install hofstadter-io/tap/hof. Existing installs can pin a specific version with hof update --version vX.Y.Z, and shell completions are provided for bash, zsh, fish, and PowerShell.

How it compares

The facts provided here do not list commercial products that hof replaces, and no direct alternative is named in the README or the topic list. hof therefore stands alone in this registry: the closest named technologies, CUE and Dagger, are the foundations and runtime it builds upon rather than substitutes for it.

When to use it — and when not to

Adopting hof means adding a local binary and a set of CUE-based conventions to an existing workflow; the README describes no database, storage service, or mail server to operate, so the operational surface stays small. It does assume willingness to work in CUE, and teams whose schemas and pipelines are already expressed in another configuration language will need to translate them before the generator and task engine pay off. The hof chat assistant is marked alpha, so nobody should depend on it for stable production automation yet, and the repository currently carries 74 open issues.

project readme (upstream, from github) — read inline

hof - the higher order framework

A tool that unifies data models, schemas, code generation, and a task engine.

hof is a CLI tool you add to your workflow.

  • Foundation in CUE
  • Deterministic and Agentic code generation
  • Data models that can evolve and be input to code generation
  • Task engine based on cue/flow
  • Agent servers and VS Code extension
Core Features
code generation Data + templates = _ (anything), technology agnostic
data modeling Define, checkpoint, and diff data models
task engine Extensible task and DAG workflow engine
CUE cmds Core def, eval, export, and vet commands
creators bootstraping and starter kits from any repo
modules CUE module dependency management
tui A terminal interface to Hof and CUE
chat Combine LLM and Hof code gen for better, scalable results

hof uses CUE to power the DX and implementation. We believe CUE is a great language for specifying schemas, configuration, and generally for writing anything declarative or this is a source of truth. It has good theory and comes from the same people that brought us containers, Go, and Kubernetes.

Learn more about CUE: cuelang.org | cuetorials.com

Documentation

Please see docs.hofstadter.io to learn more.

The getting-started section will take you on a tour of hof. The the-walkthrough section shows you how to build and use a generator.

Join us or ask questions on

We also use GitHub issues and discussions. Use which every is easiest for you!

Installation

You can find the latest downloads on our GitHub releases page. This is the preferred method.

If you already have hof, install a specific version with hof update --version vX.Y.Z.

# Homebrew
brew install hofstadter-io/tap/hof

# Shell Completions (bash, zsh, fish, power-shell)
echo ". <(hof completion bash)" >> $HOME/.profile
source $HOME/.profile

# Show the help text or version info to verify installation
hof --help
hof version

Project Structure

A brief overview of the project structure:

  • ci/: Continuous integration scripts.
  • cmd/hof/: The main entrypoint for the hof CLI.
  • docs/: The source code for the documentation website.
  • flow/: The source for hof flow and the task engine.
  • lib/: Core logic for hof's various subcommands.
  • test/: Testscripts and testdata for hof's subcommands.

Development

To build the hof binary:

make build

To run the test suite:

make test

To run the docs website locally:

make docs-serve

Contributing & Community

We are happy to accept contributions and have a growing community. The best ways to get started are

  1. Joining our Discord
  2. Reading The Contributing Guild
  3. Finding an issue to work on. We are happy to guide you.
  4. Improving the documentation.

When you are ready to contribute, please fork the repo and submit a pull request. We use a standard PR and review process. We also have a number of labels to help organize issues and PRs.

Interfaces

There are two interfaces to hof

  1. a CLI - great for scripting and automation
  2. a TUI - great for exploring and designing

cli

hof - the higher order framework

  Learn more at https://docs.hofstadter.io

Usage:
  hof [flags] [command] [args]

Main commands:
  chat                  co-create with AI (alpha)
  create                starter kits or blueprints from any git repo
  datamodel             manage, diff, and migrate your data models
  def                   print consolidated CUE definitions
  eval                  evaluate and print CUE configuration
  export                output data in a standard format
  flow                  run workflows and tasks powered by CUE
  fmt                   format any code and manage the formatters
  gen                   CUE powered code generation
  mod                   CUE module dependency management
  tui                   a terminal interface to Hof and CUE
  vet                   validate data with CUE

Additional commands:
  help                  help about any command
  update                check for new versions and run self-updates
  version               print detailed version information
  completion            generate completion helpers for your terminal
  feedback              open an issue or discussion on GitHub

Flags:
  -E, --all-errors           print all available errors
  -h, --help                 help for hof
  -i, --ignore-errors        turn off output and assume defaults at prompts
  -D, --include-data         auto include all data files found with cue files
  -V, --inject-env           inject all ENV VARs as default tag vars
  -I, --input stringArray    extra data to unify into the root value
  -p, --package string       the Cue package context to use during execution
  -l, --path stringArray     CUE expression for single path component when placing data files
  -q, --quiet                turn off output and assume defaults at prompts
  -d, --schema stringArray   expression to select schema to apply to data files
      --stats                print generator statistics
  -0, --stdin-empty          A flag that ensure stdin is zero and does not block
  -t, --tags stringArray     @tags() to be injected into CUE code
  -v, --verbosity int        set the verbosity of output
      --with-context         add extra context for data files, usable in the -l/path flag

Use "hof [command] --help / -h" for more information about a command.

tui

The hof tui is a terminal based interface to Hof's features. It has a built in help system and documentation. The following YouTube video provides a tour.

Tour Hof's TUI

License

This project is licensed under the Apache 2.0 License. See the LICENSE file for details.

Frequently asked questions

Is hof free to use?

hof is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does hof do?

A developer experience centered on CUE. Unifies schemas, data models, deterministic and agentic code generation, workflow and task engine, dagger powered enviro

What is hof written in?

hof is primarily written in Go. Its source is publicly available at https://github.com/hofstadter-io/hof, and it has 615 GitHub stars.