awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
lonng avatar

lonng/nano

0
View on GitHub↗
3,173 stars·461 forks·Go·mit·11 views

Nano

Nano is a distributed application framework designed for building systems using an actor-based messaging model. It functions as a distributed actor framework that decouples components through asynchronous messaging to maintain state isolation across a server cluster.

The system acts as a cluster message dispatcher and session-aware request router, tracking client state to route incoming messages to the specific agent holding the session data. It utilizes a distributed agent registry to coordinate the dispatching of messages between multiple application instances acting as agents.

The framework also serves as an asynchronous task orchestrator, executing long-running background operations and synchronizing the results back into a single-threaded event loop. It manages client requests through registered components and coordinates data flow across a shared-nothing distributed architecture.

Features

  • Actor Models - Implements a distributed actor model to maintain state isolation through asynchronous message passing between independent agents.
  • Distributed Actor Frameworks - Implements a distributed actor framework that uses an actor-based messaging model to ensure state isolation across a cluster.
  • Distributed Agent Registries - Provides a distributed registry to coordinate message dispatching by tracking active agent locations across the cluster.
  • Actor-Based Message Routing - Uses independent agents to handle asynchronous messaging and state isolation across a distributed system.
  • Cluster Message Dispatchers - Provides a communication layer that routes asynchronous messages between distributed application agents across a server cluster.
  • Cluster-Wide - Routes network messages to specific cluster instances based on a distributed registry of active agent locations.
  • Session-Specific Request Routing - Tracks client session state to route incoming messages to the specific agent instance holding that session's data.
  • Asynchronous Task Orchestrators - Functions as an orchestrator for executing long-running background operations and synchronizing results into a single-threaded loop.
  • Background Worker Orchestration - Orchestrates long-running background workers and synchronizes their results back into the main execution stream.
  • Distributed Application Frameworks - Provides a framework for building distributed systems by coordinating multiple application instances acting as agents.
  • Distributed Cluster Coordination - Routes messages to specific application instances using a distributed registry of active agent locations.
  • Distributed Coordination Systems - Coordinates multiple application instances acting as agents to dispatch messages across a cluster of backend servers.
  • Shared-Nothing Architectures - Employs a shared-nothing architecture where each cluster node manages its own memory and communicates via network messages.
  • Distributed Task Orchestration - Orchestrates long-running background operations in separate threads and synchronizes results back to the main stream.
  • Client Request Handling - Processes incoming network messages through registered components and manages session state to push data back to clients.
  • Client Request Management - Processes incoming network messages through registered components and handles session states to communicate with clients.
  • Client Request Managers - Acts as a network handler that processes incoming messages and maintains session state to push data back to clients.
  • Event Loops - Utilizes a single-threaded event loop to process requests and background task completions, preventing concurrency race conditions.
  • Result Synchronization - Pipes results from long-running background operations back into the main single-threaded event loop.
  • Asynchronous Task Processing - Offloads slow operations to background threads to maintain system responsiveness and synchronize results.
  • Background Task Schedulers - Runs slow operations in background routines and synchronizes results back into the main execution thread.
  • Enterprise Backend Architectures - Provides a scalable server infrastructure that coordinates data flow between multiple distributed nodes and end users.
  • Game Development - High-performance game server framework.
  • Game Server Frameworks - Lightweight and high-performance Go game server framework.
  • Game Development - Lightweight, high-performance game server framework.

Star history

Star history chart for lonng/nanoStar history chart for lonng/nano

How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Open-source alternatives to Nano

Similar open-source projects, ranked by how many features they share with Nano.
  • puniverse/quasarpuniverse avatar

    puniverse/quasar

    4,553View on GitHub↗

    Quasar is a JVM concurrency framework that implements the actor model and a lightweight thread library. It provides isolated execution units that communicate via asynchronous message passing to eliminate shared mutable state. The project distinguishes itself through a distributed actor system capable of operating across multiple cluster nodes with location-transparent registries and actor state migration. It utilizes a work-stealing fiber scheduler to manage millions of lightweight threads, allowing tasks to suspend during non-blocking I/O operations without stalling underlying system threads

    Javaactorsconcurrencyfibers
    View on GitHub↗4,553
  • actix/actixactix avatar

    actix/actix

    9,223View on GitHub↗

    Actix is a Rust actor framework and concurrent programming toolkit designed for building applications that manage state through an asynchronous messaging system. It provides a model where independent actors serve as autonomous units of state and logic, communicating via strongly typed messages sent to unique addresses. The framework distinguishes itself by isolating state within these actors, allowing internal data to be mutated safely during message handling without the use of locks or mutexes. It employs an asynchronous mailbox system to buffer incoming requests and uses supervision strateg

    Rustactixactoractor-model
    View on GitHub↗9,223
  • lunatic-solutions/lunaticlunatic-solutions avatar

    lunatic-solutions/lunatic

    4,867View on GitHub↗

    Lunatic is a WebAssembly runtime and concurrent process manager that implements an Erlang-inspired model of lightweight concurrency and fault tolerance. It functions as a distributed actor system where isolated processes communicate via message passing across a network of linked nodes. The system utilizes a WebAssembly sandbox environment to isolate memory and restrict system call permissions for each individual process. This capability-based security model ensures that processes are sandboxed to safely execute untrusted code. The platform provides a fault-tolerant supervision tree for hiera

    Rustactorsassemblyscripterlang
    View on GitHub↗4,867
  • vonng/ddiaVonng avatar

    Vonng/ddia

    22,648View on GitHub↗

    This project serves as a comprehensive technical reference for the architecture and design of data-intensive applications. It provides a structured analysis of the fundamental principles required to build reliable, scalable, and maintainable software systems, covering the core trade-offs inherent in modern data infrastructure. The repository explores the mechanics of distributed data management, including strategies for replication, partitioning, and achieving consensus across multiple nodes. It details the design of storage engines, indexing techniques, and transaction management models, whi

    Pythonbookdatabaseddia
    View on GitHub↗22,648
See all 30 alternatives to Nano→

Frequently asked questions

What does lonng/nano do?

Nano is a distributed application framework designed for building systems using an actor-based messaging model. It functions as a distributed actor framework that decouples components through asynchronous messaging to maintain state isolation across a server cluster.

What are the main features of lonng/nano?

The main features of lonng/nano are: Actor Models, Distributed Actor Frameworks, Distributed Agent Registries, Actor-Based Message Routing, Cluster Message Dispatchers, Cluster-Wide, Session-Specific Request Routing, Asynchronous Task Orchestrators.

What are some open-source alternatives to lonng/nano?

Open-source alternatives to lonng/nano include: puniverse/quasar — Quasar is a JVM concurrency framework that implements the actor model and a lightweight thread library. It provides… actix/actix — Actix is a Rust actor framework and concurrent programming toolkit designed for building applications that manage… lunatic-solutions/lunatic — Lunatic is a WebAssembly runtime and concurrent process manager that implements an Erlang-inspired model of… vonng/ddia — This project serves as a comprehensive technical reference for the architecture and design of data-intensive… topfreegames/pitaya — Scalable game server framework with clustering support and client libraries for iOS, Android, Unity and others through… name5566/leaf — Leaf is a game server framework written in Go designed for building multiplayer game backends. It provides a modular…