A forge for disciplined Go.
GoForge is the workspace discipline. Everything else here was forged with
it — property testing, spec-to-test generation, trunk guardrails, a hex editor, BLAKE3
hashing, web-page runtimes, even a dependently typed language. All MIT,
all one go install away.
The forge index
Every artifact, grouped by what it does for you.
Build & test Go
Workspaces, spec-to-test generation, trunk discipline, and API manifests.
GoForge
Polylith-style workspaces for Go
Organize a single Go module into reusable bricks (components and bases) composed into deployable projects. Derives the dependency graph from your Go imports, classifies every brick by determinism and effectfulness, and checks, tests, and builds only what changed.
Cupel
English specs to Go tests, via Claude
Turns an English-language spec into Go tests by calling Claude (example, parameterized/data-driven, and property-based), writes them into a goforge component, and runs `goforge check` on the result. Cupel is itself a goforge workspace, so it obeys the worker-type discipline it enforces.
Refine
Richer contracts. Ordinary schemas.
Haskell-style refinement contracts for OpenAPI 3, Avro, and JSON Schema. Generate ordinary schemas, English explanations, validators, Java 25 models, and validated JSON/Avro serde. Java 25 Maven builds need no Go executable.
Propkin
Property testing that stays executable Gherkin
A lossless Gherkin superset for property testing. Property and Forall declarations compile deterministically to ordinary Cucumber features, while native Hypothesis and jqwik 1.9.3 adapters generate, shrink, replay, and promote counterexamples without replacing existing step definitions.
tbd
Trunk-based development over git
A thin, opinionated wrapper over git's DAG that keeps trunk-based workflows safe: before any operation it enforces one rule, that the trunk head must be an ancestor of whatever you touch. Diverged feature branches are rebased onto the latest trunk automatically, with the move shown as a before/after graph. v2.3.4 authors its workflow vocabulary in Go+, journals release completion as a resumable saga, validates release versions as SemVer, writes state atomically, and moves deploy/release refs through observed compare-and-swap.
assayxport
A codebase's API composition as deterministic JSON
Assaying analyzes a metal to report its exact composition; assayxport analyzes a codebase to report its exact API composition — where each symbol lives, its package, signature, docs, whether it is a runnable entrypoint, and who it calls — as a deterministic JSON manifest at the project root, so an LLM, docgen, or tool reads one map instead of reparsing everything. Supports Go (native `go/packages`) plus Python, Java, TypeScript, and JavaScript through pure-Go, cgo-free tree-sitter parsers. Its progressive explorer streams large repositories, prioritizes visible work, and incrementally merges package summaries.
Agile Frontier
Dependency-aware delivery planning in your browser
Turns a JSON backlog into a dependency-aware delivery plan. It schedules stories across workers, computes the critical path and latest safe start times, and colors urgency from red through yellow to green so the next available work is obvious. The planning core is written in Go+ and runs locally in the browser as WebAssembly.
resty
Replayability-safe typed HTTP client
A Go+ semantic rewrite of go-resty/resty with method, body replayability, and decode phase in the request type. One-shot bodies cannot be retried; outcomes exhaustively separate HTTP, transport, decode, and cancellation failures; response bodies have explicit ownership. At least 3.45x faster with 55.2% fewer allocations than the pinned Resty v2.17.2 baseline.
participle
Grammar-indexed parser construction
A Go+ semantic rewrite of Participle with token-count-indexed spans, grammar-bound FIRST evidence, explicit lookahead and commit, exhaustive diagnostics, and checked dynamic grammar binding. On the pinned v2.1.4 assignment workload it is at least 39.3x faster with 96.8% fewer allocations. Version 0.3 generates both Go and Java 25 from one Go+ source set and publishes dev.goforge:participle:0.3.0 on Maven Central.
GoSMT
Native typed SMT solving in Go+
A pure Go+/Go SMT solver pinned against Z3 4.16.0, with solver-neutral essentials in the Go+ standard library, width- and sort-indexed APIs, SMT-LIB execution, deterministic oracle corpora, and independently gated allocation and throughput performance.
Quicken Build
One build contract for every Quicken target
Go+ build orchestration for WebAssembly, TUI, Windows, macOS, Linux, iOS, and Android. Owns toolchain diagnostics, artifacts, simulator installation, and launch behind a versioned application manifest.
Lo (gplodash)
Lodash-style Go collections, at 100% parity
A complete Go+ rewrite of samber/lo v1.53.0 — all 651 declarations across the root, lazy iterator (it), mutable, and parallel packages, differential and property tested. Compatible helpers coexist with total options/results, destination-buffer operations, non-empty sequences, sized vectors, and exhaustive Search outcomes. The it package is a thin facade over std/iter.
Validator (gpvalidator)
Struct/field validation that retains evidence
A complete Go+ rewrite of go-playground/validator v10.30.3 — all 106 public declarations and 210 documented behaviors across the root and 22 translation packages, verified by a 3,077-case diagnostic panic/error matrix and a multi-million-execution fuzz gate. Typed, composable rules feed the std/validate algebra; validation facts survive past success.
Pydantic (gpydantic)
Pydantic's validation core, on typed refinements
A Go+ rewrite of pydantic v2's validation core and the second consumer of the std/validate refinement algebra. Constraints (gt/ge/lt/le/multiple_of/ min_length/max_length/pattern) compile to typed atoms; Optional[T] and Union forced std/validate to grow a disjunction axis — a nil-biased Nullable and a symmetric Or. Failures project into pydantic's exact type/loc/msg/ctx.
Brigadier (gbrigadier)
The command tree, as the GADT it is
A Go+ rewrite of Mojang/brigadier — the command parser and dispatcher — at feature parity across all 44 classes, verified by 170 ported JUnit tests. Consumes std/parsec for its scanner; the command tree is modelled as a genuine GADT (ArgumentType[T] erasing at the CommandNode[S] boundary, typed recovery via GetArgument[T]), validating Go+'s dependent machinery on a real industrial GADT with no compiler extension required.
esbuild (gesbuild)
esbuild in Go+ — AST reshaped into real enums
A Go+ rewrite of evanw/esbuild (v0.28.1) — the JS/TS/CSS bundler — blessed v1.0.0. 100% feature parity verified by esbuild's entire test suite (16 packages green under -race), authored as a goplus project (~94k LOC in .gp, 105 packages) with the AST core reshaped into real Go+ enums: the expression/statement/binding hierarchies (E/40, S/33, B/4) are genuine enums, not sealed interfaces, representation-compatibly so parity holds. Differential + property tested, gen-check + vet clean. Honest scope in PARITY.md (match awaits goplus pointer-variant support; token T stays uint8 by design).
jsoup (gpsoup)
HTML parsing — the DOM as a GADT
A Go+ rewrite of jhy/jsoup (jsoup-1.22.2) at full feature parity: the DOM is a //goplus:box pointer enum GADT whose variants share a *nodeCore, with every shared op an exhaustive match, and deep traversals use Go+ tail recursion (tail func + recur). v1.0.0 ports every jsoup subsystem — the ~69-state HTML5 tokenizer, the full tree-construction algorithm (24 insertion modes, foster parenting, adoption agency), the pretty-printer, .text(), the complete 2125-entry entity table, the full CSS Evaluator/QueryParser (combinators, pseudo-classes, :matchText, node selectors, namespaces), the safety/Cleaner sanitizer, the HTTP Connection layer (consuming std/http), the XML parser with namespaces, and a genuinely incremental StreamParser. Every subsystem is differentially tested against jsoup's own JUnit oracle cases; the parity ledger is the null set. v1.0.1 pushes the buffered rune scanner down into std/text/scan and the byte-level charset detection/decoding into std/charset (std v0.208.0), consuming them with no functional change. Requires the goplus v0.140.1 toolchain.
GJSON (gpgjson)
Compiled JSON paths with typed results
A complete Go+ rewrite of tidwall/gjson v1.19.0 — all 45 declarations and 1,301/1,301 pinned deterministic path cases exact. Immutable compiled paths, validated indexed documents, exhaustive lookup, modifiers, JSON-lines streaming, typed JSON/CBOR paths, and a permissive compatibility evaluator hardened by a differential fuzz gate. Forced std/pathquery.
Viper (gpviper)
Immutable typed configuration with provenance
A complete Go+ rewrite of spf13/viper v1.21.0 — all 192 declarations: defaults, files/readers, environment, flags, overrides, aliases, codecs, finders, file/remote watching, immutable snapshots, ordered reload, typed conversions, and the Unmarshal family. Backed by the std/config core; immutable snapshot lookup is ~8.6x faster with zero allocations.
Chi (gpchi)
Immutable, typed HTTP routing
A complete Go+ rewrite of go-chi/chi v5.3.1 — all 127 declarations across the root (54) and middleware (73) packages. Core routing, regex/wildcard patterns, parameters, grouping, mounting, custom 404/405, deterministic immutable compilation, and the full request-lifecycle middleware slice. Semantic resolution is an exhaustive MatchOutcome enum over std/http/route.
direnv (gpdirenv)
Per-directory environments, typed at the core
A Go+ rewrite of direnv v2.37.1 with differential-verified parity — pure cores (dotenv, sri, gzenv, env, all 12 shell renderers, xdg) proven byte-exact against upstream, the effectful engine + all 23 CLI commands in Go+, and stdlib.sh embedded byte-identical. Closed sums are Go+ enums (AllowStatus, sri.Algo) with wire-preserving projections. gen-check clean against goplus v0.138.0.
Task (gptask)
The task runner, rewritten in Go+
A fully Go+-authored rewrite of go-task/task v3.52.0 — executor engine, Taskfile schema, templater, up-to-date fingerprinting, and CLI in 92 .gp files, byte-identical to the upstream binary across a broad differential battery (deps, vars, preconditions, requires, output styles, includes, dotenv, sources/generates up-to-date). gen-check clean against goplus v0.139.0. The Taskfile schema keeps its structural YAML unions (no forced enums), preserving the wire format exactly.
yq (gpyq)
The YAML/JSON/XML processor, rewritten in Go+
A fully Go+-authored rewrite of mikefarah/yq v4.53.3 — the expression lexer/parser, operator library, and YAML/JSON/XML/TOML/CSV/properties/lua/ base64/uri codecs in 115 .gp files, byte-identical to the upstream binary across a ~60-case multi-format battery. The installable artifact is still `yq` (go install goforge.dev/gpyq/cmd/yq). gen-check clean against goplus v0.139.0. Zero forced enums — yq's discriminators are wire-coupled bitsets/ structs, so the formats stay byte-exact.
sqlc (gpsqlc)
SQL to type-safe code, rewritten in Go+
A Go+-authored rewrite of sqlc-dev/sqlc v1.31.1 — the SQL-to-type-safe-code compiler. Its hand-written core is 396 .gp files (internal/config, compiler, codegen, sql ast/catalog/rewrite, cmd); the machine-generated SQL parsers (ANTLR) and protobuf stay Go. sqlc generate is byte-identical to upstream; the golden endtoend suite (886 subtests, postgresql/mysql/sqlite x Go/ Kotlin/Python) passes. Binary installs as `sqlc`. gen-check clean against goplus v0.139.0; zero forced enums (kinds are wire-coupled ordinals/ interfaces).
GoReleaser (gpreleaser)
The release pipeline, rewritten in Go+
A Go+-authored rewrite of goreleaser/goreleaser v2.17.0 — the release- automation pipeline. 204 .gp files cover every internal/pipe stage (archive/build/docker/brew/nix/publish/release/changelog), builders, pkg, and cmd; only //go:embed template shims stay Go. goreleaser check is byte- identical to upstream; 120 packages pass. Binary installs as `goreleaser`. gen-check clean against goplus v0.139.0; zero forced enums (kinds are wire/ config-coupled).
At the terminal
Daily CLI craft: viewing, navigating, inspecting, hashing.
Rubric
bat in Go — a cat clone with wings
A Go port of sharkdp's `bat`: a `cat(1)` clone with syntax highlighting and themes (via chroma — ~296 languages, ~74 themes), git change markers, line ranges and highlighting, wrapping, and paging. Built as a goforge workspace.
blake3sum
BLAKE3 hashing — library + b3sum CLI
A fast BLAKE3 hashing library and a `b3sum`-compatible CLI in Go. Streaming, one-shot, and keyed APIs, plus a parallel batch API (`HashMany`) tuned for hashing many small, independent nodes at once. Built as a goforge workspace.
lsf
lf-style file manager with highlighted previews
A minimal `lf`-style terminal file manager whose preview pane renders text with syntax highlighting (via chroma) and a line-number gutter, the way bat and rubric do. Three miller columns: parent, current, and preview.
etch & scry
Hex editor + viewer for the terminal
Two hex tools in one goforge workspace: `etch`, a full-screen terminal hex editor (offset/hex/ASCII panes, nibble-wise editing, undo, overwrite-only writes), and `scry`, an xxd-style viewer with hexyl-style colors, paged like rubric. lsf uses both for binary files.
Render & serve the web
Page regions, serving strategies, and pixel-honest layout.
scribe
Layout lines between the pixels, not on them
A metalworker's scriber scratches dimensionless layout lines on metal before any cut is made; scribe draws the same way. Coordinates name the grid lines between pixels (the QuickDraw corner-grid model), corners are table-driven cubic Beziers (circular kappa or Apple's continuous squircle), and rendering is deterministic: identical input gives byte-identical PNGs on every platform. One serializable display list renders to raster, exact SVG, or your terminal, driven by a PostScript-homage drawing language.
Quicken
One Cadence application, every interface
The Web, TUI, Desktop, Mobile, and shared Native interpreters for Cadence. Keep one model, closed message algebra, update function, commands, and semantic views while each runtime owns only platform mechanics.
cadence
One Go+ program, multiple interface runtimes
A target-independent Elm Architecture core: model, closed messages, update, commands, subscriptions, semantic elements, immutable styles, components, and validated execution plans shared by browser, server, terminal, and GUI.
Quicken Web
Full-stack Go+ browser programs
Full-page and island SSR, typed DOM hydration, remote commands, and resumable server-owned live sessions with a tiny generic JavaScript loader.
PaletteGen
UI palettes from colors or pictures
Build complete UI palettes from pictures or manual colors, with an optional secondary brand scale, exact pixel sampling, pinch zoom, live refinement, undo, and session history. Live palette preview, examples navigation, mobile editing, pinned PDF/JSON exports, and Auto/light/dark themes. Authored in goml, available in your browser or as a self-contained server binary.
Applied & experimental
An app and a language, forged with the same discipline.
Rune
A content-addressed, dependently typed language
The kernel of a small, content-addressed, dependently typed language: a finished proof is a value identified by the hash of its content, so verification becomes a cache with no invalidation logic. v1 shipped the foundation — glued-NbE type checking, observational equality (funext computes), totality by construction, quantities, a JS erasure backend. v2 added quotients and set-level truncation; v3 adds a second equality stratum — two-level type theory with a fibrant universe and postulated univalence, where transport computes through ua — plus an ergonomics ladder (infix operators, numeric literals, case, calc) and a ten-lesson course. All as surface sugar and builtin content-addressed groups: no new core syntax, no hash-format change.
Go+
Richer abstractions, portable Go
A strict superset of Go that compiles to portable, idiomatic Go — generated packages are consumed without the Go+ toolchain, the Kotlin/JVM interoperability story for Go. Its dependent surface now supports refinements, indexed values, GADTs, existential packaging, transparent representations, cross-package witnesses, and solver-backed standard packages. Wraps the go toolchain (goplus gen/build/test/run/vet), verifies before writing with errors mapped to .gp lines, and adds a deterministic, checked Java 25+ target with source, JAR, runtime-ABI, JPMS artifacts, and signed Maven Central Portal publication bundles. v0.144.0 adds goml, an ML-family (SML/OCaml/Idris2/Lean4-flavored) second surface: .goml sources generate through the same pipeline into the same portable Go, and `goml repl` evaluates it interactively by compiling and running rather than interpreting. It is specified executably by its Cucumber/Godog suite and EBNF grammar delta.
Anvil
Meeting times across all your calendars
Finds meeting slots across many people, each carrying busy time merged from any number of calendars — personal, work, volunteer — with drive-time padding for in-person meetings. Reads iCal URLs, CalDAV, and Google Calendar; writes the invite too. `anvil serve` hosts self-hostable scheduling links (Meet links minted on booking) and an installable agenda PWA with join links and directions. No Exchange, no Outlook.
Eclaire
One semantic layout across native targets
A C ABI and versioned semantic UI contract powered by a pinned Clay revision. The same layout core serves Go, Haskell, F#, Rust, JavaScript FFI, and native desktop, iOS, and Android builds; GoForge adapters connect Cadence elements to Quicken Native.
Quicken Desktop
Cadence applications on Windows, macOS, and Linux
Native desktop application and window lifecycle over the shared Quicken Native Gio interpreter.
Quicken Mobile
Cadence applications on iOS and Android
Native mobile lifecycle, environment, safe areas, navigation, and typed device capabilities over the shared Quicken Native renderer.
More on the way
New tools join the forge over time.
GoForge eats its own cooking
GoForge is the workspace tool. The other tools are built as goforge workspaces themselves — they obey the discipline they ship under.
The core: split a Go module into reusable bricks, classify each by determinism and effectfulness, and check, test, and build only what changed.
Propkin adds shrinking properties to executable Gherkin. Cupel turns specs into checked Go tests. tbd keeps trunk-based Git flows honest. Rubric, etch, scry, and lsf cover daily terminal work without leaving the suite.
Anvil applies the same small, testable-core approach to calendar scheduling. Each project page links to install commands, docs, source, and package metadata.
Start with GoForge.
Turn a single Go module into a workspace of reusable bricks, checked and tested incrementally.