# ergo-services/ergo **Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/ergo-services-ergo).** 4,441 stars · 177 forks · Go · mit ## Links - GitHub: https://github.com/ergo-services/ergo - Homepage: https://docs.ergo.services - awesome-repositories: https://awesome-repositories.com/repository/ergo-services-ergo.md ## Topics `actor-model` `actors` `distributed` `distributed-systems` `elixir` `ergo-framework` `erlang` `event-driven` `event-driven-microservices` `framework` `go` `golang` `microservice` `microservices-architecture` `network-transparency` `otp` `otp-applications` `supervisor` `workflow` `workflow-engine` ## Description Ergo is a distributed actor framework for Go that implements the Erlang distribution protocol, enabling the construction of resilient, concurrent applications that can communicate transparently with Erlang/OTP nodes. At its core, it provides an actor model with isolated lightweight processes, priority-ordered mailboxes, and a meta-process architecture that separates blocking I/O from sequential message handling to prevent actor freezing. The framework includes a Raft-inspired cluster consensus system for leader election and automatic failover, along with OTP-style supervision trees that organize processes hierarchically for automatic crash detection and configurable restart strategies. The framework distinguishes itself through its native Erlang interoperability, allowing Go and Erlang nodes to exchange messages using the Erlang DIST protocol and Erlang Term Format encoding. It offers a complete set of distributed systems primitives including transparent cross-node messaging, cluster membership management with peer discovery, and topology-agnostic deployment that lets the same application code run as a monolith or across multiple nodes by changing only the entry point configuration. Ergo also provides a server-sent events streaming platform where each HTTP connection is managed as a cluster-addressable actor, supporting typed event dispatch, reconnection handling, and distribution across handler pools. Beyond its core actor and distributed systems capabilities, Ergo includes a scheduled job execution system with crontab syntax, timezone handling, and remote execution across nodes. The framework provides comprehensive observability through Prometheus metrics collection, structured logging with lock-free asynchronous output, and a web-based node inspector for examining processes, network stacks, and application state. A command-line scaffolding tool generates project skeletons, supervisors, process pools, and network servers to accelerate development. ## Tags ### Networking & Communication - [Erlang Distribution Protocol Implementations](https://awesome-repositories.com/f/networking-communication/erlang-distribution-protocol-implementations.md) — Implements the Erlang DIST protocol and Term Format for transparent messaging between Go and Erlang/OTP nodes. - [Actor Message Handlings](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/communication-platforms/messaging-middleware/message-handling-systems/actor-message-handlings.md) — Processes messages from priority-ordered mailboxes via callbacks that receive the sender and message. ([source](https://docs.ergo.services/actors/actor.md)) - [Split-Brain Prevention Mechanisms](https://awesome-repositories.com/f/networking-communication/distributed-consensus-algorithms/split-brain-prevention-mechanisms.md) — Ergo ensures only one leader exists per term by requiring a majority vote, preventing split-brain scenarios during network partitions. ([source](https://docs.ergo.services/extra-library/actors/leader)) - [Raft Consensus Implementations](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-systems-coordination/distributed-consensus-protocols/raft-consensus-implementations.md) — Provides a Raft-inspired consensus protocol for leader election and automatic failover across distributed nodes. - [Node Handshake Implementations](https://awesome-repositories.com/f/networking-communication/erlang-distribution-protocol-implementations/node-handshake-implementations.md) — Ergo executes the Erlang node handshake protocol to authenticate and establish connections between nodes. ([source](https://docs.ergo.services/extra-library/network-protocols/erlang)) - [Erlang Distribution Protocols](https://awesome-repositories.com/f/networking-communication/erlang-distribution-protocols.md) — Implements the Erlang DIST protocol for transparent messaging between Go and Erlang/OTP nodes. ([source](https://docs.ergo.services/extra-library/network-protocols/erlang)) - [Erlang Port Mapper Daemon Registrations](https://awesome-repositories.com/f/networking-communication/erlang-port-mapper-daemon-registrations.md) — Ergo registers a node with the Erlang Port Mapper Daemon so other nodes can discover and connect to it. ([source](https://docs.ergo.services/extra-library/network-protocols/erlang)) - [Location-Transparent Message Transmission](https://awesome-repositories.com/f/networking-communication/location-transparent-message-transmission.md) — Ergo delivers messages to processes on the same or remote nodes using identical code, with automatic connection management and message encoding. ([source](https://docs.ergo.services/readme.md)) - [Message Passing](https://awesome-repositories.com/f/networking-communication/message-passing.md) — Exchanges data between isolated processes through asynchronous messages and synchronous request-response patterns. ([source](https://cdn.jsdelivr.net/gh/ergo-services/ergo@master/README.md)) - [Message Routing](https://awesome-repositories.com/f/networking-communication/message-routing.md) — Delivers messages directly to local mailboxes or establishes network connections for remote delivery, hiding distribution complexity. ([source](https://docs.ergo.services/basics/node)) - [TCP Connection Pooling](https://awesome-repositories.com/f/networking-communication/network-transport-protocols/tcp-connection-pooling.md) — Ergo creates TCP connection pools between nodes, negotiating protocol version and compression during handshake. ([source](https://docs.ergo.services/basics/node.md)) - [Server-Sent Events](https://awesome-repositories.com/f/networking-communication/server-sent-events.md) — Streams unidirectional server-to-client updates over HTTP using SSE with each connection as an addressable actor. ([source](https://docs.ergo.services/extra-library/meta-processes/sse)) - [Typed SSE Event Dispatchers](https://awesome-repositories.com/f/networking-communication/server-sent-events/sse-sources/typed-sse-event-dispatchers.md) — Ergo sends structured events with optional event type, data, message ID, and retry hint to a specific SSE connection or broadcasts to all connections. ([source](https://docs.ergo.services/extra-library/meta-processes/sse.md)) - [Publish-Subscribe Messaging](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/publish-subscribe-messaging.md) — Sends messages to all subscribers of a registered event, with the event producer explicitly publishing each message. ([source](https://docs.ergo.services/advanced/pub-sub-internals)) - [Cross-Application Event Pub-Sub](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/publish-subscribe-messaging/cross-application-event-pub-sub.md) — Ergo broadcasts typed events from one application and lets other applications subscribe to them without knowing the publisher's location. ([source](https://docs.ergo.services/basics/project-structure.md)) - [Actor-Driven SSE Push](https://awesome-repositories.com/f/networking-communication/communication-protocols-architectures/communication-paradigms/server-to-client-event-emissions/actor-driven-sse-push.md) — Ergo allows backend actors to push formatted SSE events to connected clients at any time through the actor message system. ([source](https://docs.ergo.services/extra-library/meta-processes/sse)) - [Remote Delivery Failure Detection](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-systems-coordination/distributed-systems-configuration/heartbeat-and-timeout-configurations/node-failure-detection/remote-delivery-failure-detection.md) — Ergo provides immediate error notification for missing remote processes when using the Important delivery flag, matching local failure semantics. ([source](https://docs.ergo.services/readme.md)) - [Cluster Peer Broadcasting](https://awesome-repositories.com/f/networking-communication/instant-messaging-services/peer-to-peer-messaging/cluster-peer-broadcasting.md) — Ergo sends a message to all discovered peers or bootstrap peers, enabling state dissemination across the cluster. ([source](https://docs.ergo.services/extra-library/actors/leader.md)) - [Connection Lifecycle Management](https://awesome-repositories.com/f/networking-communication/network-reliability-diagnostics/connection-session-management/connection-management/connection-lifecycle-management.md) — Handles connection establishment, heartbeat keep-alives, and cleanup with actor notifications on connect and disconnect. ([source](https://docs.ergo.services/extra-library/meta-processes/sse)) - [External Resource Writes](https://awesome-repositories.com/f/networking-communication/protocol-to-actor-bridging/external-resource-writes.md) — Receives commands from actors and writes to external resources like sockets or processes. ([source](https://docs.ergo.services/basics/meta-process.md)) - [Remote Application Launches](https://awesome-repositories.com/f/networking-communication/remote-application-launches.md) — Ergo launches a loaded but inactive application on another cluster node, running it under that node's supervision tree. ([source](https://docs.ergo.services/networking/remote-start-application)) - [SSE Sources](https://awesome-repositories.com/f/networking-communication/server-sent-events/sse-sources.md) — Establishes client-side SSE connections to external servers, reading and parsing events for actor delivery. ([source](https://docs.ergo.services/extra-library/meta-processes/sse.md)) - [Cluster-Wide SSE Addressing](https://awesome-repositories.com/f/networking-communication/sse-session-management/cluster-wide-sse-addressing.md) — Ergo sends events to any SSE connection from any node in the cluster using its alias, enabling distributed push notifications. ([source](https://docs.ergo.services/extra-library/meta-processes/sse.md)) - [SSE Connection Lifecycle Events](https://awesome-repositories.com/f/networking-communication/sse-session-management/sse-connection-lifecycle-events.md) — Ergo receives connect, disconnect, and reconnection messages for each SSE connection, enabling tracking and cleanup of client state. ([source](https://docs.ergo.services/extra-library/meta-processes/sse.md)) - [Meta-Process Connection Acceptances](https://awesome-repositories.com/f/networking-communication/tcp-connection-lifecycles/tcp-connection-acceptance/meta-process-connection-acceptances.md) — Accepts incoming network connections in the external reader and spawns child meta-processes to handle each one. ([source](https://docs.ergo.services/basics/meta-process.md)) ### Software Engineering & Architecture - [Distributed Actor Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/distributed-actor-frameworks.md) — Building resilient, concurrent applications using the actor model with isolated processes and asynchronous message passing. - [Distributed Orchestration Platforms](https://awesome-repositories.com/f/software-engineering-architecture/distributed-orchestration-platforms.md) — Manages actor lifecycles, supervision trees, and transparent message routing across a cluster of nodes. - [Distributed Service Coordination](https://awesome-repositories.com/f/software-engineering-architecture/distributed-service-coordination.md) — Managing cluster membership, leader election, and service discovery across multiple nodes for coordinated application deployment. - [Supervision Recovery Strategies](https://awesome-repositories.com/f/software-engineering-architecture/job-continuation-chaining/parent-child-dependencies/supervision-recovery-strategies.md) — Organizes actors into supervision hierarchies with configurable restart strategies for automatic crash recovery. - [Message Versioning](https://awesome-repositories.com/f/software-engineering-architecture/library-conflict-resolution/graceful-version-coexistence/message-versioning.md) — Ergo creates a new Go type for each version of a message so that old and new nodes can coexist during a rolling upgrade. ([source](https://docs.ergo.services/advanced/message-versioning)) - [Distributed Node Lifecycles](https://awesome-repositories.com/f/software-engineering-architecture/node-lifecycle-management/distributed-node-lifecycles.md) — Ergo starts, stops, and configures a node instance, including application management and network settings. ([source](https://docs.ergo.services/basics/generic-types.md)) - [Actor Node Lifecycles](https://awesome-repositories.com/f/software-engineering-architecture/node-lifecycle-management/distributed-node-lifecycles/actor-node-lifecycles.md) — Ergo starts and controls a node, spawning processes, managing applications, and configuring networking from any goroutine. ([source](https://docs.ergo.services/basics/generic-types)) - [Temporary Process Aliases](https://awesome-repositories.com/f/software-engineering-architecture/distributed-actor-frameworks/abstract-actor-addressing/temporary-process-aliases.md) — Ergo generates multiple temporary identifiers for a single process to support flexible addressing patterns like request-response. ([source](https://docs.ergo.services/basics/process.md)) - [Event Subscribers](https://awesome-repositories.com/f/software-engineering-architecture/event-subscribers.md) — Receives high-priority event messages for cross-cutting concerns like configuration changes or cache invalidation. ([source](https://docs.ergo.services/actors/actor.md)) - [Topology-Agnostic Decompositions](https://awesome-repositories.com/f/software-engineering-architecture/monolithic-architectures/monolith-decompositions/topology-agnostic-decompositions.md) — Ergo splits a single application into separate packages and creates new entry points without changing any application code. ([source](https://docs.ergo.services/basics/project-structure.md)) - [Lock-Free](https://awesome-repositories.com/f/software-engineering-architecture/queues/lock-free.md) — Queues log messages in a lock-free MPSC queue and writes them in a background goroutine so actors never block on disk I/O. - [Process Pools](https://awesome-repositories.com/f/software-engineering-architecture/task-scheduling/parallel-task-executors/parallel-task-spawning/process-pools.md) — Generates a pool of worker processes with configurable size for concurrent task execution via CLI scaffolding. ([source](https://docs.ergo.services/tools/ergo)) - [Address-Type Message Routings](https://awesome-repositories.com/f/software-engineering-architecture/type-based-message-routing/address-type-message-routings.md) — Ships a message routing system that dispatches to different callbacks based on the address type of the recipient. ([source](https://docs.ergo.services/actors/actor.md)) ### Artificial Intelligence & ML - [Distributed Node Registrars](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-services/service-registrars/distributed-node-registrars.md) — Ergo retrieves connection parameters from a registrar service and uses them to establish links between nodes. ([source](https://docs.ergo.services/networking/behind-the-nat)) - [Topology-Agnostic Deployments](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-orchestration-multi-agent/deployment-architectures/deployment-topologies/topology-agnostic-deployments.md) — Ergo runs the same application code as a monolith or distributed across nodes by changing only the entry point configuration. ([source](https://docs.ergo.services/basics/project-structure)) - [Crontab-Based Schedulers](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-architectures/orchestration-engines/ai-agent/runtime-execution-control/recurring-agent-scheduling/recurring-task-scheduling/crontab-based-schedulers.md) — Schedules recurring jobs using crontab syntax with automatic timezone and daylight saving handling. ([source](https://docs.ergo.services/basics/cron.md)) ### Part of an Awesome List - [Process Spawning](https://awesome-repositories.com/f/awesome-lists/devtools/actor-model/process-spawning.md) — Creates lightweight actor processes in their own goroutines with priority-ordered mailboxes for concurrent message handling. ([source](https://docs.ergo.services/basics/process.md)) - [Meta-Process Spawnings](https://awesome-repositories.com/f/awesome-lists/devtools/actor-model/process-spawning/meta-process-spawnings.md) — Launches processes with two goroutines to separate blocking I/O from sequential message handling. ([source](https://docs.ergo.services/basics/meta-process)) - [Process Termination](https://awesome-repositories.com/f/awesome-lists/devtools/actor-model/process-termination.md) — Stops processes gracefully by returning an error from the handler, running cleanup callbacks, and freeing resources. ([source](https://docs.ergo.services/basics/process.md)) - [Meta-Process Lifecycle Cascades](https://awesome-repositories.com/f/awesome-lists/devtools/actor-model/process-termination/meta-process-lifecycle-cascades.md) — Ergo automatically stops all meta-processes when their owning process exits, keeping the supervision tree clean. ([source](https://docs.ergo.services/basics/meta-process)) - [Developer Tools](https://awesome-repositories.com/f/awesome-lists/devtools/developer-tools.md) — Actor-based framework with network transparency. ### Data & Databases - [Erlang Term Format Encoding](https://awesome-repositories.com/f/data-databases/data-encoding/erlang-term-format-encoding.md) — Ergo converts Go data types to and from the Erlang Term Format (ETF) for network transmission. ([source](https://docs.ergo.services/extra-library/network-protocols/erlang)) - [Message Callback Handlings](https://awesome-repositories.com/f/data-databases/data-exchange-protocols/runtime-data-exchange/actor-messaging/message-callback-handlings.md) — Implements message and call handlers via a high-level actor abstraction that hides mailbox mechanics. ([source](https://docs.ergo.services/basics/process.md)) - [Actor Startup Sequences](https://awesome-repositories.com/f/data-databases/task-queues/sequential-task-processing/actor-startup-sequences.md) — Ergo launches the listed actors sequentially, registering named ones for discovery, and aborts the group if any single process fails to start. ([source](https://docs.ergo.services/basics/application)) - [Deferred Response Processing](https://awesome-repositories.com/f/data-databases/data-exchange-protocols/runtime-data-exchange/actor-messaging/deferred-response-processing.md) — Defers synchronous request replies by returning nil from the callback and later sending the response via a request reference. ([source](https://docs.ergo.services/actors/actor.md)) - [External Event Ingestions](https://awesome-repositories.com/f/data-databases/data-exchange-protocols/runtime-data-exchange/actor-messaging/external-event-ingestions.md) — Reads data from blocking sources in an external reader and sends it as messages to actors. ([source](https://docs.ergo.services/basics/meta-process.md)) - [Message Visibility Levels](https://awesome-repositories.com/f/data-databases/data-exchange-protocols/runtime-data-exchange/actor-messaging/message-visibility-levels.md) — Enforces message visibility levels to control which actors can send, receive, or serialize specific message types. ([source](https://docs.ergo.services/basics/project-structure.md)) - [High-Priority Pool Interceptions](https://awesome-repositories.com/f/data-databases/data-exchange-protocols/runtime-data-exchange/actor-messaging/priority-queue-handling/high-priority-pool-interceptions.md) — Handles urgent system-level messages directly in the pool actor rather than forwarding them to workers. ([source](https://docs.ergo.services/actors/pool.md)) - [Process Identifiers](https://awesome-repositories.com/f/data-databases/data-management/unique-identifier-generators/process-identifiers.md) — Ergo assigns each process a unique PID containing node name, sequential ID, and creation timestamp to detect node restarts. ([source](https://docs.ergo.services/basics/generic-types)) - [Cross-Stack Type Contracts](https://awesome-repositories.com/f/data-databases/data-type-definitions/schema-type-synchronization/cross-stack-type-contracts.md) — Defines cross-application message contracts in a separate types package for decoupled data exchange. ([source](https://docs.ergo.services/basics/project-structure.md)) ### Development Tools & Productivity - [Actor Pool Routers](https://awesome-repositories.com/f/development-tools-productivity/targeting-utilities/round-robin-target-distribution/actor-pool-routers.md) — Ergo routes incoming messages and requests to one of several identical worker actors, automatically balancing load and handling worker lifecycle. ([source](https://docs.ergo.services/actors/pool.md)) - [Priority Mailboxes](https://awesome-repositories.com/f/development-tools-productivity/task-prioritization/asynchronous-queue-prioritization/priority-mailboxes.md) — Implements priority-ordered mailboxes with four queues per actor process for urgent system messages. - [Remote Application Restart Policies](https://awesome-repositories.com/f/development-tools-productivity/application-startup-configurations/remote-application-restart-policies.md) — Ergo specifies whether a remotely started application restarts on failure by choosing Temporary, Transient, or Permanent behavior. ([source](https://docs.ergo.services/networking/remote-start-application)) - [Termination Policies](https://awesome-repositories.com/f/development-tools-productivity/build-tooling/build-orchestration-logic/build-orchestration-configuration/build-automation-systems/workflow-execution/child-workflow-orchestration/termination-policies.md) — Sets a mode controlling whether the application stops on any process exit, only abnormal exits, or continues until all finish. ([source](https://docs.ergo.services/basics/application)) - [Module Dependency Declarations](https://awesome-repositories.com/f/development-tools-productivity/external-module-declarations/runtime-module-declarations/module-dependency-declarations.md) — Ensures that required applications or services are running before starting the current application. ([source](https://docs.ergo.services/basics/application.md)) - [Remote Reference Staleness Detections](https://awesome-repositories.com/f/development-tools-productivity/search-indexing-tools/local-file-indexers/index-staleness-detection/remote-reference-staleness-detections.md) — Ergo compares creation timestamps on every remote operation to prevent sending messages to restarted nodes. ([source](https://docs.ergo.services/basics/node.md)) ### DevOps & Infrastructure - [Cluster Membership Coordination](https://awesome-repositories.com/f/devops-infrastructure/cluster-membership-coordination.md) — Ergo notifies actors when peers join or leave the cluster, and supports dynamic peer addition via a Join method. ([source](https://docs.ergo.services/extra-library/actors/leader.md)) - [Registrar-Based Node Discoveries](https://awesome-repositories.com/f/devops-infrastructure/cluster-node-management/automated-node-discovery/registrar-based-node-discoveries.md) — Ergo finds other nodes using a local registrar or a centralized registry service like etcd. ([source](https://docs.ergo.services/basics/node.md)) - [Distributed Leader Election](https://awesome-repositories.com/f/devops-infrastructure/distributed-leader-election.md) — Ergo elects a single leader among distributed actor instances using a consensus protocol, with automatic failover and heartbeat-based health checks. ([source](https://docs.ergo.services/extra-library/actors.md)) - [Quorum-Based Elections](https://awesome-repositories.com/f/devops-infrastructure/remote-cluster-access/cluster-failover-managers/automated-master-failovers/quorum-based-elections.md) — Elects a single leader among distributed nodes using a Raft-inspired consensus protocol with automatic failover. - [Restart Strategies](https://awesome-repositories.com/f/devops-infrastructure/restart-automation/process-restarts/restart-strategies.md) — Chooses whether to restart only the failed child, all children, or children in dependency order based on their relationships. ([source](https://docs.ergo.services/basics/supervision-tree.md)) - [Supervised Process Restarts](https://awesome-repositories.com/f/devops-infrastructure/restart-automation/process-restarts/restart-strategies/supervised-process-restarts.md) — Monitors child processes and automatically restarts them when they crash using configurable restart strategies. ([source](https://docs.ergo.services/basics/supervision-tree.md)) - [Automatic Worker Replacement](https://awesome-repositories.com/f/devops-infrastructure/worker-pool-management/local-worker-pools/automatic-worker-replacement.md) — Automatically detects worker crashes and spawns replacement actors to maintain processing capacity. ([source](https://docs.ergo.services/actors/pool.md)) - [Leader Election Event Handlers](https://awesome-repositories.com/f/devops-infrastructure/distributed-leader-election/leader-election-event-handlers.md) — Ergo triggers application-defined callbacks when a node becomes leader or follower, allowing custom logic for each state. ([source](https://docs.ergo.services/extra-library/actors/leader)) - [Graceful Shutdowns](https://awesome-repositories.com/f/devops-infrastructure/graceful-shutdowns.md) — Ergo sends exit signals to all processes and waits for cleanup, or kills them immediately without waiting. ([source](https://docs.ergo.services/basics/node.md)) - [Application Shutdown Lifecycles](https://awesome-repositories.com/f/devops-infrastructure/graceful-shutdowns/application-shutdown-lifecycles.md) — Stops the entire application when a process terminates abnormally or normally, based on the configured mode. ([source](https://docs.ergo.services/basics/application.md)) - [Leader Status Inspections](https://awesome-repositories.com/f/devops-infrastructure/high-availability-systems/leader-election/leader-status-inspections.md) — Ergo provides methods to check if the current process is the leader, retrieve the leader's PID, and inspect the current election term. ([source](https://docs.ergo.services/extra-library/actors/leader.md)) - [Actor-Based Application Units](https://awesome-repositories.com/f/devops-infrastructure/self-hosted-applications/self-contained-bundles/actor-based-application-units.md) — Organizes code into independent applications with their own actors, supervision trees, and message contracts. ([source](https://docs.ergo.services/basics/project-structure)) - [Dynamic Pool Scalings](https://awesome-repositories.com/f/devops-infrastructure/worker-pool-management/local-worker-pools/dynamic-pool-scalings.md) — Adds or removes worker actors at runtime to adjust processing capacity without restarting the pool. ([source](https://docs.ergo.services/actors/pool.md)) ### Game Development - [Actor Management](https://awesome-repositories.com/f/game-development/simulation-engines/simulation-worlds/actor-management.md) — Provides an actor model framework for spawning and managing concurrent actors with lifecycle control. ([source](https://docs.ergo.services/basics/generic-types.md)) ### Operating Systems & Systems Programming - [Process Lifecycle Managers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/process-lifecycle-orchestrators/process-lifecycle-managers.md) — Ergo transitions a process through init, sleep, running, and terminated states, with automatic cleanup of resources on exit. ([source](https://docs.ergo.services/basics/process.md)) - [Actor Exit Signal Trapping](https://awesome-repositories.com/f/operating-systems-systems-programming/system-signal-handling/actor-exit-signal-trapping.md) — Converts exit signals from linked processes into regular messages so actors can handle failures without terminating. ([source](https://docs.ergo.services/actors/actor.md)) - [Graceful Actor Terminations](https://awesome-repositories.com/f/operating-systems-systems-programming/system-signal-handling/actor-exit-signal-trapping/actor-termination-verification/graceful-actor-terminations.md) — Stops actors gracefully by returning a termination reason from a handler and running cleanup callbacks. ([source](https://docs.ergo.services/actors/actor.md)) ### Programming Languages & Runtimes - [Blocking I/O Offloading](https://awesome-repositories.com/f/programming-languages-runtimes/async-i-o-runtimes/blocking-i-o-offloading.md) — Spawns each actor with two goroutines for blocking I/O and sequential message handling to prevent actor freezing. - [Actor Name Registries](https://awesome-repositories.com/f/programming-languages-runtimes/literal-matching/literal-pattern-matching/actor-name-registries.md) — Ergo registers actors under symbolic names so they can be reached without knowing their runtime identifier. ([source](https://docs.ergo.services/basics/generic-types.md)) - [Actor Name Registrations](https://awesome-repositories.com/f/programming-languages-runtimes/literal-matching/literal-pattern-matching/process-name-mapping/actor-name-registrations.md) — Ergo maps human-readable names to process identifiers so well-known services can be addressed without tracking dynamic PIDs. ([source](https://docs.ergo.services/basics/node)) - [Supervision Trees](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/supervision-trees.md) — Organizes processes into hierarchical supervision trees that automatically detect crashes and restart workers. - [Blocking I/O Message Sends](https://awesome-repositories.com/f/programming-languages-runtimes/async-i-o-runtimes/blocking-i-o-offloading/blocking-i-o-message-sends.md) — Lets the blocking I/O goroutine push events into the actor system without blocking the message handler. ([source](https://docs.ergo.services/basics/meta-process)) ### System Administration & Monitoring - [Application Grouping](https://awesome-repositories.com/f/system-administration-monitoring/application-grouping.md) — Groups related actors into a single unit with defined startup order, lifecycle management, and fault-tolerance rules. ([source](https://docs.ergo.services/basics/application.md)) - [Nested Supervisor Hierarchies](https://awesome-repositories.com/f/system-administration-monitoring/background-process-management/automatic-crash-recovery/process-supervisors/supervisor-based-recovery/nested-supervisor-hierarchies.md) — Nests supervisors as children of other supervisors to form a tree where each level manages its own recovery scope. ([source](https://docs.ergo.services/basics/supervision-tree.md)) - [Actor Request-Reply Patterns](https://awesome-repositories.com/f/system-administration-monitoring/log-analysis-tools/latency-monitoring/request-reply/actor-request-reply-patterns.md) — Ergo responds to a blocking caller by returning a result from a callback, with separate channels for transport and application errors. ([source](https://docs.ergo.services/actors/actor.md)) - [OTP-Style Supervision Trees](https://awesome-repositories.com/f/system-administration-monitoring/process-supervision/otp-style-supervision-trees.md) — Automatically detecting and restarting failed processes using OTP-style supervision trees with configurable recovery strategies. - [Asynchronous Logging](https://awesome-repositories.com/f/system-administration-monitoring/asynchronous-logging.md) — Ergo queues log messages in a lock-free MPSC queue and writes them in a background goroutine, so actors never block on disk I/O. ([source](https://docs.ergo.services/extra-library/loggers/rotate.md)) - [Custom Metric Collectors](https://awesome-repositories.com/f/system-administration-monitoring/global-metric-registries/custom-metric-collectors.md) — Registers custom Prometheus collectors updated via periodic callbacks or event-driven message handling. ([source](https://docs.ergo.services/extra-library/actors/metrics.md)) - [Real-Time Node Health Monitors](https://awesome-repositories.com/f/system-administration-monitoring/health-monitoring/instance-health-monitors/microservices-health-monitoring/master-node-health-monitors/real-time-node-health-monitors.md) — Displays live graphs of process count, running processes, and memory usage over the last 60 seconds. ([source](https://docs.ergo.services/tools/observer)) - [Centralized Logging Architectures](https://awesome-repositories.com/f/system-administration-monitoring/logging/application-logging-configurations/centralized-logging-architectures.md) — Centralizes log distribution from all sources through a single subsystem with severity-based fan-out. ([source](https://docs.ergo.services/basics/logging.md)) - [Node and Process Inspectors](https://awesome-repositories.com/f/system-administration-monitoring/master-node-inspection/node-detail-inspectors/node-and-process-inspectors.md) — Ships a web-based inspector for examining nodes, network stacks, applications, and all active processes. ([source](https://cdn.jsdelivr.net/gh/ergo-services/ergo@master/README.md)) - [Node Status Web Interfaces](https://awesome-repositories.com/f/system-administration-monitoring/master-node-inspection/node-status-web-interfaces.md) — Opens a web interface displaying node status, network activity, and all running processes. ([source](https://docs.ergo.services/extra-library/applications/observer.md)) - [Process State Inspection](https://awesome-repositories.com/f/system-administration-monitoring/process-state-inspection.md) — Views internal state of any process or meta-process running on the node through a web interface. ([source](https://docs.ergo.services/extra-library/applications/observer.md)) - [Prometheus System Metrics Exporters](https://awesome-repositories.com/f/system-administration-monitoring/prometheus-exporters/prometheus-based-metric-exporters/prometheus-system-metrics-exporters.md) — Collects and exposes runtime metrics, process statistics, and application telemetry in Prometheus format. - [System Telemetry Collectors](https://awesome-repositories.com/f/system-administration-monitoring/system-telemetry-collectors.md) — Ergo automatically gathers process counts, memory usage, CPU time, and network traffic across the actor system. ([source](https://docs.ergo.services/extra-library/actors/metrics.md)) ### Security & Cryptography - [Client Certificate Authentication](https://awesome-repositories.com/f/security-cryptography/client-certificate-authentication.md) — Verifies client certificates against a CA pool for mutual TLS authentication of connections. ([source](https://docs.ergo.services/basics/certmanager.md)) - [Cluster Communication Security](https://awesome-repositories.com/f/security-cryptography/cluster-security/cluster-communication-security.md) — Authenticates and encrypts cluster-internal communication using mutual TLS with configurable certificate management. ([source](https://cdn.jsdelivr.net/gh/ergo-services/ergo@master/README.md)) ### Testing & Quality Assurance - [Actor Test Sandboxing](https://awesome-repositories.com/f/testing-quality-assurance/actor-test-sandboxing.md) — Tests individual actors and full applications in isolated environments, including multi-node distributed scenarios. ([source](https://docs.ergo.services/basics/project-structure.md)) ### Web Development - [Shared Message Contracts](https://awesome-repositories.com/f/web-development/application-messaging-interfaces/shared-message-contracts.md) — Places inter-application message types in a shared package so applications communicate without compile-time dependencies. ([source](https://docs.ergo.services/basics/project-structure)) - [Private Service Contracts](https://awesome-repositories.com/f/web-development/application-messaging-interfaces/shared-message-contracts/private-service-contracts.md) — Ergo defines private messages for direct service-to-service communication where the receiver owns the contract. ([source](https://docs.ergo.services/advanced/message-versioning))