Sample Applications

Explore complete, working examples of Goose applications to accelerate your learning and development.

Sandbox Repository

The Goose Sandbox contains reference implementations for all supported platform types. These examples demonstrate real-world patterns and best practices.

📦 Repository: github.com/awesome-goose/sandbox

Available Examples

Application Description Platform
api/ REST API with JSON responses API
web/ Server-rendered web application Web
cli/ Command-line interface tool CLI
multi/ Multi-platform application API + Web + CLI

API Example

A REST API application demonstrating:

  • JSON response handling
  • RESTful routing patterns
  • Resource modules with CRUD operations
  • Dependency injection
  • Structured logging
cd sandbox/api
go mod tidy
go run main.go
# Server starts at http://localhost:8080

Endpoints:

  • GET / - Health check
  • GET /user - List all users
  • GET /user/:id - Get user by ID

Web Example

A server-rendered web application demonstrating:

  • HTML template rendering
  • Form handling
  • Static file serving
  • Session management patterns
cd sandbox/web
go mod tidy
go run main.go
# Server starts at http://localhost:8080

CLI Example

A command-line application demonstrating:

  • Command registration
  • Argument and flag handling
  • Output formatting
  • Interactive prompts
cd sandbox/cli
go mod tidy
go run main.go

Multi-Platform Example

A single codebase serving multiple platforms:

  • Shared business logic across platforms
  • API endpoints (port 8080)
  • Web interface (port 3000)
  • CLI commands
cd sandbox/multi
go mod tidy
go run main.go

This example shows how to:

  • Structure code for multi-platform support
  • Share services and modules between platforms
  • Configure platform-specific settings

Project Structure

Each sandbox application follows the standard Goose module structure:

app/
├── main.go              # Application entry point
├── config.yaml          # Configuration file
├── go.mod               # Go module definition
├── app/
│   ├── app.module.go    # Root module
│   ├── app.controller.go
│   ├── app.service.go
│   ├── app.routes.go
│   └── app.dtos.go
└── [feature]/           # Feature modules
    ├── [feature].module.go
    ├── [feature].controller.go
    ├── [feature].service.go
    ├── [feature].routes.go
    └── [feature].dtos.go

Running Examples Locally

  1. Clone the sandbox repository:

    git clone https://github.com/awesome-goose/sandbox.git
cd sandbox

  2. Choose an example:

    cd api  # or web, cli, multi

  3. Install dependencies and run:

    go mod tidy
go run main.go

Using as Templates

The sandbox examples can serve as starting points for your own applications:

  1. Copy the example that matches your use case
  2. Update go.mod with your module name
  3. Modify the application code as needed

Or use the Goose CLI to scaffold a new project:

# Create from template
goose app --name=myproject --template=api
goose app --name=myproject --template=web
goose app --name=myproject --template=cli
goose app --name=myproject --template=multi

Next Steps