100% Go — Zero JavaScript

Real-time Web Apps
Without JavaScript

GoliveKit brings Phoenix LiveView to Go. Build interactive applications with server-rendered components that update instantly via WebSocket — write everything in Go.

Get Started See it in Action GitHub

See it in Action

This counter updates in real-time via WebSocket — no page reload needed

Interactive Counter

0

Click the buttons — changes sync instantly

Live Stats

Active Visitors 373
Total Clicks 44
Your Session 0s

Why GoliveKit?

Everything you need to build modern web applications

Instant Response

Optimistic UI with <10ms perceived latency. Click feedback is instant, server confirms async.

Zero JavaScript

Write your entire application in Go. Server-side rendering with minimal DOM patches.

Islands Architecture

Selective hydration for optimal performance. Interactive components only where needed.

Type-Safe Forms

Ecto-inspired changesets with validation. Strong typing from form to database.

Secure by Default

CSRF protection, input sanitization, rate limiting, and authentication built-in.

Observable

Structured logging, Prometheus metrics, and OpenTelemetry tracing integration.

27+ Packages

Modular architecture for maximum flexibility

Core
core
Component lifecycle & Socket
Core
router
HTTP routing & LiveView
Core
transport
WebSocket, SSE, Polling
UI
diff
Hybrid HTML differ
UI
forms
Ecto-style changesets
UI
islands
Selective hydration
UI
a11y
Accessibility helpers
State
state
State persistence
State
presence
User presence tracking
State
pubsub
Real-time broadcasts
DevOps
logging
Structured logging
DevOps
metrics
Prometheus metrics
DevOps
tracing
OpenTelemetry tracing
DevOps
shutdown
Graceful shutdown
Security
security
CSRF & sanitization
Security
limits
Rate limiting
Security
recovery
Panic recovery
Utils
retry
Exponential backoff
Utils
pool
Buffer pools
Utils
protocol
Wire protocol
Utils
i18n
Internationalization
Utils
uploads
File uploads
Utils
testing
Test utilities
Utils
js
JS commands
Utils
streaming
SSR streaming
Plugins
plugin
Hook system
CLI
new
Create project
CLI
dev
Dev server
CLI
build
Production build
CLI
generate
Code generation

Simple & Powerful

Write your components in pure Go with a familiar lifecycle

counter.go 
type Counter struct {
    core.BaseComponent
    count int
}

func (c *Counter) Mount(ctx context.Context, params core.Params, session core.Session) error {
    c.count = 0
    return nil
}

func (c *Counter) HandleEvent(ctx context.Context, event string, payload map[string]any) error {
    switch event {
    case "increment":
        c.count++
    case "decrement":
        c.count--
    }
    return nil
}

func (c *Counter) Render(ctx context.Context) core.Renderer {
    return core.HTML(fmt.Sprintf(`
        <div>
            <span>Count: %d</span>
            <button lv-click="decrement">-</button>
            <button lv-click="increment">+</button>
        </div>
    `, c.count))
}

How It Works

Server-rendered components with real-time DOM updates

     Browser                              Server
  ┌───────────────┐                  ┌─────────────────────────────┐
  │               │   HTTP Request   │                             │
  │     DOM       │ ───────────────► │  Component.Mount()          │
  │               │                  │       │                     │
  │               │ ◄─────────────── │       ▼                     │
  │               │   Full HTML      │  Component.Render() → HTML  │
  │               │                  │                             │
  └───────┬───────┘                  └──────────────┬──────────────┘
          │                                         │
          │           WebSocket                     │
          │ ◄──────────────────────────────────────►│
          │                                         │
  ┌───────▼───────┐                  ┌──────────────▼──────────────┐
  │               │   User Event     │                             │
  │  lv-click     │ ───────────────► │  Component.HandleEvent()    │
  │  lv-change    │                  │       │                     │
  │  lv-submit    │ ◄─────────────── │       ▼                     │
  │               │   Minimal Diff   │  Diff Engine → Patch        │
  └───────────────┘                  └─────────────────────────────┘

Developer Experience

Powerful CLI for rapid development

Terminal
$ golive new myapp
→ Creates project structure with routing, components, and templates
$ golive dev
→ Starts dev server with hot reload and file watching
$ golive build
→ Builds optimized production binary to dist/
$ golive generate live Counter
→ Generates LiveView component with boilerplate

Get Started in 3 Steps

From zero to real-time in under a minute

1

Install

go install github.com/gabrielmiguelok/golivekit/cmd/golive@latest

Install the GoliveKit CLI globally

2

Create

golive new myapp && cd myapp

Scaffold a new project with routing and components

3

Run

golive dev

Start the dev server at http://localhost:3000