Skip to content

framework-comparison.md

Latest commit

 

History

History
277 lines (218 loc) · 10.1 KB

framework-comparison.md

File metadata and controls

277 lines (218 loc) · 10.1 KB

Core Web vs. Other Rust Web Frameworks

This document provides a detailed comparison between Core Web and other popular Rust web frameworks, highlighting the unique features and advantages of Core Web.

Overview

Core Web is not just a web framework, but a complete, production-ready platform that includes multiple protocols, advanced security features, enterprise-grade observability, and multi-database integration. While frameworks like Axum and Rocket focus primarily on HTTP handling, Core Web provides a comprehensive solution for building scalable, secure web applications.

Comparison with Axum

Core Features

Feature Core Web Axum
HTTP Framework Built on Axum Axum
Multi-Protocol Support REST, GraphQL, gRPC, WebSocket HTTP only
Authentication JWT, OIDC, API Keys Manual implementation
Authorization RBAC/ABAC with Casbin/Cedar Manual implementation
Caching Moka (in-memory) + Redis (distributed) Manual implementation
Database Integration MySQL, Redis, MongoDB, ClickHouse Manual implementation
Observability OpenTelemetry (tracing, metrics, logs) Manual implementation
Resilience Patterns Retry, Circuit Breaker, Bulkhead Manual implementation
Rate Limiting Token bucket algorithm Manual implementation
Security Headers HSTS, CSP, CORS/CSRF protection Manual implementation

Architecture

Axum:

  • Lightweight, modular framework focused on HTTP request handling
  • Built on tokio and hyper
  • Emphasizes type safety and performance
  • Requires manual integration of additional components

Core Web:

  • Full-stack platform with integrated components
  • Built on Axum as the HTTP foundation
  • Includes enterprise-grade features out of the box
  • Provides opinionated architecture for production systems

Use Cases

Axum is ideal for:

  • Simple APIs and microservices
  • Projects requiring maximum flexibility
  • Developers who prefer to build their own stack
  • Lightweight applications with minimal dependencies

Core Web is ideal for:

  • Enterprise applications requiring security and compliance
  • Projects needing multi-protocol support
  • Teams wanting to reduce development time with pre-built components
  • Applications requiring comprehensive observability
  • Projects with complex authorization requirements

Comparison with Rocket

Core Features

Feature Core Web Rocket
HTTP Framework Axum-based Rocket-specific
Request Handling Extractors Guards
Response Types Type-safe Type-safe
Middleware Tower-based Fairings
Routing Macro-based Attribute-based
Testing Built-in test utilities Built-in test utilities
Async Support Full async/await Async via tokio
Compile-time Checks Extensive Moderate

Design Philosophy

Rocket:

  • Developer experience focused
  • Convention over configuration
  • Magic through code generation
  • Easy to get started with
  • Opinionated framework design

Core Web:

  • Production readiness focused
  • Explicit configuration over convention
  • No hidden magic
  • Comprehensive feature set
  • Modular architecture

Performance

Both frameworks offer excellent performance, but with different trade-offs:

Rocket:

  • Slightly higher compile times due to code generation
  • Runtime overhead is minimal
  • Excellent for rapid prototyping

Core Web:

  • Optimized for production workloads
  • Lower runtime overhead due to explicit design
  • Better suited for high-throughput applications

Comparison with Actix Web

Core Features

Feature Core Web Actix Web
HTTP Framework Axum-based Actix-based
Actor Model Not included Built-in
WebSockets Full support Full support
HTTP/2 Supported Supported
Performance Excellent Excellent
Middleware Tower-based Actix-specific
Testing Comprehensive Good

Architecture Differences

Actix Web:

  • Built on the actor model
  • High performance through async/await
  • Mature ecosystem
  • Steeper learning curve due to actor concepts

Core Web:

  • Built on modern async/await patterns
  • Modular component architecture
  • Easier learning curve for newcomers
  • More comprehensive feature set

Unique Advantages of Core Web

1. Multi-Protocol Support

Unlike other frameworks that focus solely on HTTP, Core Web provides:

  • REST API with full CRUD operations
  • GraphQL with schema and resolvers
  • gRPC with Protocol Buffer service contracts
  • WebSocket/SSE for real-time communication

2. Enterprise-Grade Security

Core Web includes comprehensive security features:

  • Authentication: JWT, OIDC, and API key support
  • Authorization: RBAC and ABAC with Casbin/Cedar
  • Security Headers: HSTS, CSP, CORS/CSRF protection
  • Compliance: Data protection regulation compliance

3. Multi-Database Integration

Core Web provides seamless integration with multiple database systems:

  • MySQL - Primary transactional database
  • Redis - Caching, session storage, and pub/sub messaging
  • MongoDB - Document storage for flexible schemas
  • ClickHouse - Analytics and time-series data warehouse

4. Advanced Observability

Core Web implements comprehensive observability:

  • Distributed Tracing with OpenTelemetry
  • Metrics Collection and dashboarding
  • Structured Logging with multiple output formats
  • Health Checks with Kubernetes-ready endpoints

5. Resilience Patterns

Core Web includes proven resilience patterns:

  • Retry Mechanisms with exponential backoff
  • Circuit Breaker for fault tolerance
  • Bulkhead for resource isolation
  • Timeout for preventing resource exhaustion

6. Performance Optimization

Core Web is optimized for high performance:

  • Caching Layers: In-memory (Moka) and Redis distributed caching
  • Connection Pooling: Efficient database connection management
  • Async/Await: Non-blocking I/O for maximum throughput
  • Resource Management: Memory-efficient data structures

When to Choose Core Web

Choose Core Web when you need:

  1. Enterprise Features: Security, observability, and compliance
  2. Multi-Protocol Support: REST, GraphQL, gRPC, and WebSockets
  3. Multi-Database Integration: MySQL, Redis, MongoDB, ClickHouse
  4. Rapid Development: Pre-built components reduce development time
  5. Production Readiness: Battle-tested patterns and best practices
  6. Scalability: Designed for horizontal scaling and high concurrency

Choose Axum when you need:

  1. Maximum Flexibility: Build your own stack from scratch
  2. Lightweight Applications: Minimal dependencies and overhead
  3. Custom Architecture: Full control over component selection
  4. Learning Rust: Simpler framework to understand fundamentals

Choose Rocket when you need:

  1. Developer Experience: Convention over configuration
  2. Rapid Prototyping: Quick to get started with
  3. Type Safety: Excellent compile-time guarantees
  4. Expressive Syntax: Clean, readable code

Choose Actix Web when you need:

  1. Maximum Performance: Highest throughput requirements
  2. Actor Model: Applications benefiting from actor patterns
  3. Mature Ecosystem: Established community and libraries
  4. WebSockets: Heavy WebSocket usage

Migration from Other Frameworks

From Axum

Migration from Axum is straightforward since Core Web is built on Axum:

  1. Existing Axum handlers can often be used directly
  2. Middleware may need adaptation to Tower-based system
  3. Benefit from added security and observability features

From Rocket

Migration requires more changes due to different design philosophies:

  1. Replace Rocket guards with Axum extractors
  2. Adapt routing from attribute-based to macro-based
  3. Reimplement authentication/authorization systems

From Actix Web

Migration involves significant changes:

  1. Replace actor patterns with async/await
  2. Adapt middleware to Tower-based system
  3. Reimplement routing and request handling

Performance Benchmarks

While specific benchmarks depend on implementation details, Core Web's performance characteristics include:

HTTP Throughput

  • Comparable to Axum and Actix Web for HTTP requests
  • Slight overhead from additional middleware (security, observability)
  • Optimized for real-world production scenarios

Memory Usage

  • Efficient memory management through Rust's ownership system
  • Configurable caching strategies
  • Resource pooling for database connections

Concurrency

  • Excellent async/await support
  • Thread-safe operations
  • Scalable to thousands of concurrent connections

Ecosystem and Community

Core Web

  • Newer project with growing community
  • Comprehensive documentation and examples
  • Active development with regular updates
  • Enterprise-focused support

Axum

  • Backed by the Tokio team
  • Large, active community
  • Excellent documentation
  • Part of the broader Rust async ecosystem

Rocket

  • Mature project with stable API
  • Strong community and ecosystem
  • Excellent documentation and guides
  • Academic backing and research

Actix Web

  • One of the most popular Rust web frameworks
  • Large community and extensive ecosystem
  • Proven in production environments
  • Active development and maintenance

Conclusion

Core Web differentiates itself by providing a complete, production-ready platform rather than just a web framework. While Axum, Rocket, and Actix Web excel in their respective domains, Core Web offers:

  1. Comprehensive Feature Set: Security, observability, multi-protocol support
  2. Enterprise Readiness: Compliance, monitoring, and resilience patterns
  3. Reduced Development Time: Pre-built components and integrations
  4. Scalability: Designed for high-concurrency, distributed systems
  5. Maintainability: Opinionated architecture and best practices

Choose Core Web when you need a complete solution for building secure, scalable web applications. Choose other frameworks when you need maximum flexibility or have specific requirements that don't align with Core Web's architecture.

For teams looking to reduce time-to-market while maintaining high quality and security standards, Core Web provides an excellent foundation for modern web applications.