github.com/terrastruct/d2

D2 stands out for its intuitive text-based syntax that feels natural even on day one. The Go API is straightforward - you typically just compile D2 source strings and get SVG/PNG output. Error messages are remarkably helpful, pinpointing syntax issues with line numbers and suggesting fixes, which makes debugging DSL errors much less painful than typical parser libraries.

The official documentation includes practical examples covering common diagram patterns (flowcharts, sequence diagrams, network diagrams). The playground on their website is invaluable for testing syntax before integrating into your code. GitHub issues get responses within days, and the maintainers are receptive to bug reports.

One gotcha: layout engine selection matters significantly for output quality, and the defaults don't always produce ideal results for complex diagrams. You'll need to experiment with dagre, elk, or tala engines. Also, programmatic manipulation of D2 AST is possible but underdocumented - most examples focus on string templating, which works but feels primitive for dynamic diagram generation.

D2 is a declarative diagramming library that compiles text to SVG/PNG diagrams. In production use, it's excellent for programmatic diagram generation but comes with operational considerations. The library spawns external layout engine processes (ELK, dagre, TALA), which means you're managing child processes and their lifecycle. Memory usage can spike significantly for complex diagrams—I've seen 500MB+ for moderately complex network topologies.

Error handling is straightforward but errors from the layout engines can be cryptic. The library doesn't provide built-in retry mechanisms or circuit breakers, so you'll need to wrap calls yourself. Timeouts must be managed at the context level since diagram compilation can take 5-30 seconds for complex layouts. No connection pooling is needed, but you should rate-limit diagram generation to avoid resource exhaustion.

Configuration is flexible through compile options, but breaking changes between minor versions have caught me twice—diagram output changed subtly after updates. Logging is minimal; you'll want to add your own instrumentation around compilation calls. For high-throughput scenarios, consider pre-generating diagrams or aggressive caching.

D2 provides an elegant DSL for generating diagrams programmatically, but using it in production services requires careful consideration. The library spawns external layout engine processes (dagre, ELK, etc.) which introduces significant operational complexity. You'll need to manage subprocess lifecycle, handle process crashes gracefully, and deal with unpredictable memory consumption under load. Timeout configuration exists but defaults can be problematic with complex diagrams.

Error handling is reasonable for parsing errors but less predictable when layout engines fail or hang. There's no built-in connection pooling for layout engines, so you're responsible for implementing worker pools to prevent resource exhaustion. Logging hooks are minimal - you'll want to wrap calls with your own instrumentation to track render times and failures. The API surface has seen breaking changes between minor versions, particularly around layout configuration.

For batch processing or low-throughput services it works well, but high-concurrency scenarios require significant wrapping infrastructure. Memory profiles show layout engines can spike unpredictably with nested structures or large graphs.