Go++

A superset of Go that provides modern features while staying true to the spirit of Go language.

Go++ is distributed under the BSD 3-Clause license, the same license used by Go. Bundled third-party components may have separate licenses; see their notices.

What's implemented?

Go++ adds expressive language features while keeping Go packages, generated code, and the familiar build toolchain in reach. The guides below explain each feature with comparisons and examples.

Language features

• Classes — Group fields and methods around an implicit this, with concise construction and generated Go structs.
• Static methods and factories — Put type-level operations on a class and provide named ways to construct values.
• Polymorphism — Use class values through compatible base types and interfaces, including when calling methods.
• Multiple inheritance — Compose behavior from multiple base classes, with qualified access when members conflict.
• Overloading — Reuse a function or method name for different arities and statically distinguishable argument types.
• Named arguments and defaults — Make call sites clearer and omit arguments that have a declared default.
• Structural records — Pass composite values without declaring one-off structs for every function boundary.
• Enums — Define closed, named value sets with grouped declarations, validation, ordered values, and member metadata.
• Lambdas and the prelude — Write concise functions and use familiar collection, string, and map helpers.
• Extension methods — Add compile-time methods to existing types, including several types in one extension block.
• String interpolation — Embed values in quoted or raw strings, with formatting and String() support.
• Regular expressions — Compile and use regular expressions through concise prelude helpers.
• Safe access — Use ?. to access members of nullable class values without repeating explicit nil checks.
• Lazy error fallback — Use ?? to evaluate a fallback only when the value on its left is absent or erroneous.
• Exception handling — Keep Go-style error values while adding throw, try, typed catch, and finally syntax.
• Program exit hook — Register atExit work that runs during normal program shutdown.
• Annotations and introspection — Declare typed metadata, validate its targets, and inspect it at runtime.

Application features and standard library

• Serialization — Generate JSON, YAML, and GOB conversion methods from class annotations and field metadata.
• HTTP servers and routes — Build servers with annotated routing, request binding, middleware, and lifecycle hooks.
• OpenAPI, Swagger, and OAuth — Generate API documentation and interactive Swagger UI, with OAuth/OIDC support.
• ORM and SQL — Map annotated models to SQL and use database operations that invoke validation and lifecycle hooks.
• Typed templates — Define HTML/XML templates as functions and render them with Go's html/template protections.
• External template reloads — Reload .gpp.tpl files during development without rebuilding the server.
• Embedded assets — Include files and directories in the program through source-level declarations.
• Cron scheduling — Schedule annotated functions or dynamic jobs with explicit start and stop controls.
• Suite-based tests — Organize tests into suites, methods, and annotations, then run them through gpp test.

Go compatibility and tooling

• Go compatibility — Use ordinary Go imports and dotted Go++ packages mapped to module paths; standalone programs can omit package main.
• Mixed Go and Go++ builds — Call Go from Go++ and Go++ from Go while compiling both languages in one project.
• Project CLI — Initialize, build, run, test, format, and inspect Go++ projects with the gpp command.
• Formatter — Format Go++ syntax consistently and check formatting in CI.
• Source documentation — Read declarations and API documentation directly from Go++ source.
• Language server — Get editor diagnostics, completion, navigation, semantic highlighting, and quick fixes.

Visual Studio Code

The Go++ VS Code extension provides Go++ syntax highlighting, snippets, formatting, and optional language-server support for diagnostics, completion, and navigation.

The editor view below shows the Todo model in the full example.

Install and build

The repository root is the installable Go++ CLI:

go install github.com/telgatech/gpp@latest

It provides one gpp executable with project commands:

gpp init|compile|build|run|clean|fmt|test|doc|env|doctor|version|lsp

Create and run a starter project:

gpp init hello
cd hello
gpp run

gpp init creates a root go.mod, runs go mod tidy, and initializes a Git repository with an init commit when the target is not already inside a Git worktree. The initial commit includes only the generated project files.

Build a native executable. Intermediate Go source remains in the hidden compiler workspace rather than beside the Go++ source:

gpp build examples/hello.gpp -o ./hello

Use gpp doctor to check the Go toolchain and embedded standard library, and gpp clean to remove generated build artifacts.

Format Go++ source with the shared canonical formatter. It uses four-space indentation, preserves comments and opaque literal/template content, and supports CI-friendly check mode:

gpp fmt examples/hello.gpp
gpp fmt --check ./...
gpp fmt --stdout examples/hello.gpp

Pass -emit-go to gpp build when you want the generated Go workspace path reported for inspection.

Go++ tests use the bundled gpp/test suite library and ordinary Go test execution underneath:

gpp test examples/testing.gpp
gpp test --tag crud examples/testing.gpp
gpp test --priority high examples/testing.gpp

The compiler's CI also runs go test ./... and scripts/smoke-examples.sh. That smoke test creates a fresh project with gpp init, copies in the complete examples tree, then runs or builds every example (and executes the Go++ testing example). Run it locally before submitting compiler changes:

./scripts/smoke-examples.sh

Inspect Go++ source-level documentation without exposing generated Go:

gpp doc gpp/http.Server
gpp doc string.TrimSpace
gpp doc --json gpp/http.Server
gpp doc --search template

Start the editor language server over standard input/output:

gpp lsp

The server keeps open-document overlays in memory and provides diagnostics, completion, hover, navigation, references, rename, symbols, formatting, and signature help without running a Go backend build on every change. Use gpp lsp --log=/tmp/gpp-lsp.log when protocol-side diagnostics are needed; logs never go to stdout.

Documentation site

The technical documentation is built with VitePress. It includes a practical landing page, getting-started and language guides, compiler/tooling notes, and the specifications mirrored from spec/ at build time:

npm install
npm run docs:dev

Build and preview the static site locally:

npm run docs:build
npm run docs:preview

Pushes to main build and deploy the site through GitHub Pages using the workflow in .github/workflows/docs.yml. In the repository settings, set Pages → Build and deployment → Source to GitHub Actions once.

Build and run

For a complete project build, use the build subcommand. It clears stale generated source, runs go mod tidy to resolve imports, and runs go build:

gpp build examples/hello.gpp

Use run for the same generation and dependency setup followed by execution:

gpp run examples/hello.gpp

During gpp run, external .gpp.tpl sources are watched when used with gpp/http.Server; valid edits reload automatically and invalid edits leave the previous templates active. Production gpp build uses the compiled template sources without starting a watcher.

Use a separate output directory when switching between standalone examples:

gpp run -output /tmp/gpp-orm examples/orm.gpp

Multiple Go++ files can be passed to the same build. For example, the cross-package example is built and run as one generated project:

gpp run \
  examples/packages/people.gpp \
  examples/packages/main.gpp

Go++ and Go can also live in the same build. The mixed-compilation examples demonstrate both directions:

gpp run -output /tmp/gpp-go-from-gpp examples/mixed/go_from_gpp
gpp run -output /tmp/gpp-go-imports-gpp examples/mixed/go_imports_gpp

The first lets Go++ call functions from native.go; the second lets ordinary Go import the generated generated/mixed package.

The ORM example also resolves its SQLite dependency automatically:

gpp run -output /tmp/gpp-orm examples/orm.gpp

Build an executable at a chosen path with -o:

gpp build -o ./hello examples/hello.gpp

Generated Go is written to a stable, per-project workspace under the system cache. The CLI creates that workspace's go.mod with the default module path generated; choose another path with -module when local Go package imports need a real module path. Set GPP_CACHE to choose the cache root:

GPP_CACHE=/var/cache/gpp gpp -module example.com/myapp examples/*.gpp

Choose a different generated output directory with -output:

gpp -output build/gpp examples/hello.gpp

The standard Go++ prelude is available automatically. Disable it for minimal or diagnostic builds with -no-prelude.

The enum example demonstrates implicit and explicit values, grouped enum declarations, validated conversion, and metadata:

gpp run examples/enums.gpp

Expression-level error fallback is demonstrated by:

gpp run examples/expr_catch.gpp

Class introspection exposes generated name, fields, methods, annotations, owner, type, get, set, and addr metadata while preserving ordinary Go structs and stdlib interoperability.