revel/revel

Features

• Controller-Based Routing - Implements an architectural pattern mapping incoming network requests to specific controller actions.
• MVC Frameworks - A framework implementing the model-view-controller pattern to separate business logic from user interface rendering.
• Full-Stack Web Frameworks - Provides a full-stack Go framework with integrated routing, template rendering, and session management.
• Go Web Frameworks - A full-stack framework for building web applications using the Go language with a focus on developer productivity.
• Hot-Reloading Systems - Monitors the workspace for file changes and automatically restarts the application to apply updates.
• Live Reloading Environments - A development environment that automatically compiles code and refreshes templates upon file changes without manual restarts.
• Automatic Parameter Mapping - Maps parsed request parameters directly to typed variables within the application code.
• Cookie Signing Utilities - Appends cryptographic signatures to browser cookies using a secret key to ensure session data integrity.
• Session & Cookie Handlers - Maintains user sessions and state across multiple requests using signed client-side cookies.
• Session Management - Decodes session cookies to maintain persistent user state across requests and provides data to templates.
• Web Session Management - Persists client state across multiple HTTP requests using server-side or cookie-based stores to maintain a stateless web tier.
• Composable Middleware Pipelines - Provides a chain of composable middleware filters to process cross-cutting concerns in the request lifecycle.
• Request Middleware - Uses request middleware to run custom logic before and after controller actions for cross-cutting concerns.
• HTML Template Renderers - Generates dynamic HTML responses by injecting data into templates through a pluggable rendering engine.
• HTTP Request Handling - Provides comprehensive utilities for parsing incoming HTTP requests to extract headers, locales, and query parameters.
• HTTP Response Handling - Implements tools for configuring HTTP response headers, status codes, and content types.
• Routing and Request Handling - Provides a comprehensive system for mapping network traffic to controllers and managing the request-response lifecycle.
• Controller Action Resolution - The project maps incoming web requests to specific controller methods by resolving the target action.
• Controller-Action Routing - Maps incoming HTTP request paths and methods to specific Go controller methods for execution.
• Dynamic Template Rendering - Performs runtime evaluation of templates with dynamic data to generate HTML output for web pages at scale.
• Go API Toolkits - A comprehensive set of tools for handling routing, parameter binding, session management, and validation in Go.
• HTML Response Renderers - Produces dynamic HTML responses by combining templates with data arguments and serving them with correct HTTP headers.
• HTML Templating Engines - Implements a general-purpose HTML templating engine to generate dynamic content by injecting data and conditional logic into views.
• HTTP Server Configuration - Manages network parameters including HTTP/HTTPS ports and SSL certificates to control server exposure.
• Reflection-Based Data Binding - Implements automatic mapping of raw request parameters and JSON bodies into typed Go variables using reflection.
• Server-Side Rendering - Generating dynamic web pages by injecting data into templates on the server before sending them to the browser.
• Request Data Binding - Automatically unmarshals raw JSON request bodies into structured Go objects.
• Request Parameter Parsers - Translates string parameters from URLs and requests into Go primitives and slices.
• Request Validation - Enforces data constraints and validates incoming URL and form parameters before business logic execution.
• HTTP Routing - Maps HTTP methods and URL paths to specific controller actions to direct web traffic.
• Server Initialization Hooks - Initializes the application environment, loads templates, and boots the HTTP engine upon startup.
• Server-Side Rendering Engines - A system for generating dynamic HTML pages using Go templates and a pluggable rendering engine.
• Template Execution Engines - Renders templates with provided data to return the final HTML response as a string.
• Unified Parameter Extraction - Extracts data from URL queries, route patterns, and form bodies into a unified structure for easy access.
• Web Server Hosting - Provides the core mechanism to listen for incoming HTTP requests on a network address and route them to handlers.
• Data Caching - The project stores frequently accessed data in memory or external clusters to decrease response times and reduce database load.
• JSON Response Serializers - Automatically converts server-side data structures into JSON strings for API response serving.
• Automatic Template Reloading - The project watches template files for changes and refreshes them in real-time to update the interface without restarting the server.
• State-Persistent Reloading - Monitors file changes to trigger an immediate application refresh and update state without manual intervention.
• String Localization - The project retrieves localized strings based on a language code with support for argument substitution and XSS protection.
• Background Job Processing - Executes asynchronous tasks independently of the main request-response cycle to prevent UI blocking.
• Application Settings Management - Manages application configuration by loading and overriding parameters from defaults and user-supplied files.
• View Argument Mapping - Assigns data to a view arguments map that is automatically available for rendering within templates.
• Lifecycle Request Handlers - Executes custom logic at specific stages of the request-response cycle for authentication and logging.
• WebSocket Managers - Manages the sending and receiving of messages over persistent WebSocket connections for real-time communication.
• In-Memory Compilation - Compiles code and templates in-memory on save to reflect changes immediately in the browser.
• Network Encryption - Encrypts network communication by loading SSL certificates and keys to serve the application over HTTPS.
• Method Interceptors - Provides hooks to execute specific logic before or after controller method invocations.
• Application Lifecycle Management - Coordinates the execution of specific initialization and shutdown tasks in a defined order.
• Application Text Translation - The project looks up and formats messages for specific locales using translation files.
• Controller Lifecycle Hooks - Executes predefined logic at specific stages of the controller lifecycle, including before, after, and panic events.
• Request Context Management - Provides mechanisms for tracking parameters and session state across the request lifecycle.
• Internationalized Content Renderers - Generates localized HTML views with built-in support for translation and regional time formatting.
• Input Validation Rules - Provides declarative rules to validate that user input meets required criteria with default error messages.
• Request Simulators - Simulates request and response cycles to verify web handler logic without requiring a live server.
• Controller Lifecycle Hooks - Implements hooks to execute predefined logic before, after, or during panics within the controller lifecycle.
• Panic Recovery - The project intercepts runtime crashes to log stack traces and serve a formatted error page.
• Diagnostic Error Pages - The project captures runtime panics and extracts source code lines and stack traces for diagnostic error pages.
• File Streaming - Streams files directly from the local filesystem to the client based on the requested path.
• Content Translation - Translates and localizes user-facing application text for different languages and regional settings.
• Middleware Configuration - Provides interfaces for registering and ordering the sequence of middleware filters applied to controllers.
• RESTful API Development - Creating web services that process JSON requests and return structured data for client applications using Go.
• Template Engine Abstractions - Provides an abstraction layer that allows multiple template engines to be used interchangeably based on file extensions.
• Template Logic - Provides syntax and control structures to manage view-level state and retrieve session data within templates.
• Static Asset Serving - Optimizes the delivery of static files and directory listings from a public directory to clients.
• WebSockets - Implements persistent bidirectional communication channels using the WebSocket protocol.
• Full-stack Frameworks - Full-stack framework focused on high developer productivity.
• Web Frameworks - High-productivity full-stack web framework for Go.

Star history