Building enterprise-grade Go libraries for high-performance applications

Kolosys creates production-ready Go libraries that solve complex challenges in concurrency, event processing, time-based operations, and framework development. We focus on developer experience, performance, and reliability.

• 🏗️ Context-Aware Design - Proper cancellation and timeout handling throughout
• ⚡ Performance First - Zero-allocation hot paths and minimal overhead
• 🛡️ Production Ready - Enterprise-grade reliability with comprehensive testing
• 🎨 Developer Experience - Intuitive APIs that developers love to use
• 🔧 Zero Dependencies - Core functionality without external dependencies

The backbone for concurrent Go applications with robust, context-aware primitives.

// Worker pool with graceful shutdown
pool := workerpool.New(4, 20, workerpool.WithName("api-workers"))
defer pool.Shutdown(ctx)

// Fair semaphore with configurable modes
sem := semaphore.NewWeighted(10, semaphore.WithFairness(semaphore.FIFO))

// Multi-tier rate limiting
limiter := ratelimit.NewMultiTier(
    ratelimit.NewTokenBucket(ratelimit.PerSecond(100), 20),
    ratelimit.NewLeakyBucket(ratelimit.PerMinute(1000), 100),
)

Key Features:

• Worker Pools - Bounded pools with context-aware submission and metrics
• Semaphores - Weighted fair semaphores with FIFO/LIFO/None fairness modes
• Rate Limiters - Token bucket, leaky bucket, and multi-tier implementations
• Pluggable Observability - Metrics, logging, and tracing hooks

Coming Soon: Circuit breakers, pipelines, task scheduling, and resource management

Enterprise-grade event systems with predictable semantics and robust delivery guarantees.

// Event emitter with Ion-powered async processing
emitter := emitter.New(emitter.Config{
    WorkerPool: pool,
    AsyncMode:  true,
})

// Event bus with topic routing
bus := bus.New(bus.Config{
    DefaultDeliveryMode: bus.AtLeastOnce,
    DefaultPartitions:   4,
})

// Saga orchestration for complex workflows
saga := saga.New(saga.Config{Store: store})

Key Features:

• Event Emitters - Sync/async emission with middleware support
• Event Bus - Topic-based routing with delivery guarantees
• Listeners - Lifecycle management with retry policies and circuit breakers
• Sagas - Event-driven workflow orchestration with compensation
• Memory Store - In-memory event storage with replay capabilities

Production Ready: At-least-once delivery, exactly-once semantics, and comprehensive observability

Zero-dependency, high-performance HTTP framework with type-safe handlers and developer-friendly APIs.

s := helix.Default()

// Type-safe handlers with automatic binding
s.GET("/users/{id}", helix.Handle(func(ctx context.Context, req struct {
    ID int `path:"id"`
}) (User, error) {
    return getUser(ctx, req.ID)
}))

// Fluent context API
s.GET("/hello", helix.HandleCtx(func(c *helix.Ctx) error {
    name := c.QueryDefault("name", "World")
    return c.OK(map[string]string{"message": "Hello, " + name + "!"})
}))

Key Features:

• Zero Dependencies - Built entirely on Go's standard library
• Type-Safe Handlers - Generic handlers with automatic request binding
• RFC 7807 Problem Details - Standardized error responses
• Modular Architecture - First-class support for route modules
• Comprehensive Middleware - Built-in suite with extensibility

High-performance cache with intelligent similarity-based lookups and pluggable eviction policies.

cache := synapse.New[string, string](
    synapse.WithMaxSize(1000),
    synapse.WithShards(16),
    synapse.WithThreshold(0.7),
    synapse.WithEviction(eviction.NewLRU(1000)),
)

cache.WithSimilarity(stringSimilarity)
cache.Set(ctx, "user:alice", "Alice's data")

// Find similar matches when exact key doesn't exist
value, key, score, found := cache.GetSimilar(ctx, "user:ali")

Key Features:

• Similarity-Based Lookups - Find approximate matches when exact keys don't exist
• Generic Types - Fully type-safe with Go generics
• Automatic Sharding - Distributes load across concurrent-safe partitions
• Pluggable Similarity - Custom similarity algorithms for your use case
• TTL Support - Automatic expiration of cache entries

Zero-dependency, high-performance HTTP client with type safety and stdlib compatibility.

Key Features:

• Zero dependencies
• Type-safe request/response handling
• Context-aware operations
• Built-in compression and metrics

Collection of thread-safe, generic data structures with rich utility methods.

users := collection.New[string, User]()

// Thread-safe operations
users.Set("alice", User{Name: "Alice", Age: 30})

// Functional programming methods
adults := users.Filter(func(user User, id string, c *collection.Collection[string, User]) bool {
    return user.Age >= 18
})

Key Features:

• Thread-Safe Collections - Concurrent-safe map-like structures
• 50+ Utility Methods - Map, Filter, Reduce, Set operations
• Generic Support - Type-safe with Go generics
• Functional Patterns - Inspired by JavaScript's Map and Array APIs

High-performance, zero-allocation WebSocket library with type-safe message handling.

conn, err := axon.Upgrade[Message](w, r, nil)
defer conn.Close(1000, "done")

msg, err := conn.Read(r.Context())
conn.Write(r.Context(), response)

Key Features:

• Zero-Allocation Hot Paths - Buffer pooling and efficient frame parsing
• Type-Safe - Generic Conn[T] for type-safe message handling
• RFC 6455 Compliant - Full WebSocket protocol implementation
• Context-Aware - Native context.Context support

Visit kolosys.com for our comprehensive documentation platform featuring:

• 📚 Unified Documentation - All libraries in one searchable platform
• 🚀 Quick Start Guides - Get up and running in minutes
• 📖 API References - Auto-generated from source code with examples
• 💡 Tutorials & Examples - Real-world usage patterns and best practices
• 📊 Performance Benchmarks - Detailed performance characteristics

• Getting Started: Step-by-step guides for each library
• Architecture Decisions: Documented design rationale and trade-offs
• Migration Guides: Smooth transitions between versions
• Performance Guides: Optimization tips and benchmarking results
• Integration Examples: Popular framework integrations

• Ion WorkerPool: <200ns Submit hot path, 0 allocations in steady state
• Ion Semaphore: <150ns Acquire/Release uncontended, <20% fairness overhead
• Nova Emitter: >100K events/second throughput on standard hardware
• Helix Router: Zero-allocation hot paths using sync.Pool
• Synapse Cache: O(1) exact lookups with intelligent sharding
• Axon WebSocket: Zero-allocation frame parsing and buffer pooling

• >95% Test Coverage - Comprehensive unit, integration, and performance tests
• Zero Critical CVEs - Regular security audits and dependency updates
• Performance Monitoring - Continuous benchmarking and regression detection
• Static Analysis - Advanced linting, formatting, and vulnerability scanning

We welcome contributions from developers of all experience levels!

1. Start Small - Look for "good first issue" labels
2. Read the Docs - Familiarize yourself with our libraries at kolosys.com
3. Join Discussions - Use GitHub Discussions for questions and ideas
4. Follow Guidelines - Each repository has detailed CONTRIBUTING.md files

# Clone any project
git clone https://github.com/kolosys/<library-name>
cd <library-name>

# Install dependencies and run tests
go mod download
go test -v -race ./...

# Format and lint
go fmt ./...
golangci-lint run

# Run benchmarks
go test -bench=. -benchmem ./...

• Be Respectful - We maintain a welcoming environment for all contributors
• Ask Questions - No question is too basic; we're here to help
• Share Ideas - Your feedback helps shape the future of our libraries
• Follow Best Practices - We maintain high code quality standards

• Market Leadership - Become a go-to choice for Go libraries
• Ecosystem Growth - Expand integration examples with popular frameworks
• Performance - Maintain industry-leading benchmarks
• Community - Foster active contributor base and feedback loops
• Documentation - Best-in-class developer experience

• Distributed Primitives - Coordination for distributed systems
• Cloud-Native Features - Kubernetes operators and service mesh integration
• Advanced Observability - Enhanced metrics, tracing, and debugging tools
• Language Interop - C/Python bindings for broader ecosystem adoption

• 🏠 Main Website - Documentation and guides
• 📊 Benchmarks - Performance comparisons
• 🐛 Issue Tracker - Report bugs or request features
• 💬 Discussions - Community Q&A and ideas
• 📰 Blog - Technical articles and updates
• 🔔 Releases - Latest updates and changelogs