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 Discord 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

A lightweight library for storing values that are only retrievable after a specified time.

// Store a promotional code that unlocks in 24 hours
capsule := timecapsule.New()
capsule.Store(ctx, "holiday-promo", "SAVE50", time.Now().Add(24*time.Hour))

// Try to open (will fail if still locked)
value, err := capsule.Open[string](ctx, "holiday-promo")
if errors.Is(err, timecapsule.ErrStillLocked) {
    fmt.Println("Promo code not yet available")
}

Perfect For:

• Delayed feature rollouts and configuration changes
• Time-locked promotional codes and trials
• Secure temporal value storage
• Scheduled task coordination

High-performance, type-safe Discord bot development for Go.

client := discord.NewClient(token,
    discord.WithIntents(discord.IntentGuildMessages),
    discord.WithCache(cache.NewMemoryCache()),
)

// Type-safe event handlers
client.OnMessageCreate(func(ctx context.Context, event *discord.MessageCreateEvent) error {
    if event.Message.Content == "!ping" {
        return client.SendMessage(ctx, event.Message.ChannelID, "Pong!")
    }
    return nil
})

Complete Discord API v10+ type definitions with helper utilities for permissions, snowflakes, and formatting.

Features:

• Complete Discord API coverage including 2024 features (Polls, User Apps, etc.)
• Zero-reflection event handling for maximum performance
• Advanced rate limiting with global, per-route, and per-resource limits
• Enterprise observability with OpenTelemetry integration
• Plugin system for extensible functionality

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
• TimeCapsule: <100ns Store/Open operations with minimal memory overhead

• 🧪 >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

┌─────────────┐    ┌──────────────┐    ┌─────────────────┐
│ TimeCapsule │    │    Nova      │    │    Discord      │
│             │    │              │    │                 │
│  Time-locked│    │ Event System │    │  Bot Framework  │
│   Storage   │    │              │    │                 │
└─────────────┘    └──────┬───────┘    └─────────────────┘
                          │
                          ▼
                   ┌──────────────┐
                   │     Ion      │
                   │              │
                   │ Concurrency  │
                   │  Primitives  │
                   └──────────────┘

• Ion serves as the foundational layer for concurrency and scheduling
• Nova builds on Ion for high-performance event processing
• TimeCapsule operates independently for time-based storage
• Discord provides specialized bot development capabilities

Microservice Architecture

// Use Ion for request processing
pool := workerpool.New(10, 100)
limiter := ratelimit.NewTokenBucket(ratelimit.PerSecond(1000), 100)

// Use Nova for event-driven communication
emitter := emitter.New(emitter.Config{WorkerPool: pool})
bus := bus.New(bus.Config{DefaultPartitions: 4})

// Use TimeCapsule for delayed operations
capsule := timecapsule.New()

• 🏆 Market Leadership - Become the go-to choice for Go concurrency primitives
• 🌍 Ecosystem Growth - Expand integration examples with popular frameworks
• ⚡ Performance Excellence - Maintain industry-leading benchmarks
• 👥 Community Building - Foster active contributor base and feedback loops
• 📚 Documentation Excellence - 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