pykka - Pykka is a Python implementation of the actor model, which makes it easier to build concurrent applications

  •        7

Pykka is a Python implementation of the actor model. The actor model introduces some simple rules to control the sharing of state and cooperation between execution units, which makes it easier to build concurrent applications. An actor is an execution unit that executes concurrently with other actors.

https://www.pykka.org
https://github.com/jodal/pykka

Tags
Implementation
License
Platform

   




Related Projects

orleans - Orleans - Distributed Virtual Actor Model


Orleans is a framework that provides a straight-forward approach to building distributed high-scale computing applications, without the need to learn and apply complex concurrency or other scaling patterns.It was created by Microsoft Research implementing the Virtual Actor Model and designed for use in the cloud.

akka.net - Port of Akka actors for .NET


Akka.NET is a community-driven port of the popular Java/Scala framework Akka to .NET.If you are interested in helping porting Akka to .NET please take a look at Contributing to Akka.NET.

Stact - An early actor framework for .NET, long since abandoned by me.


NOTE: If you are looking at the source - please run build.bat before opening the solution. It creates the SolutionVersion.cs file that is necessary for a successful build. Developing concurrent applications requires an approach that departs from current software development methods, an approach that emphasizes concurrency and communication between autonomous system components. The actor model defines a system of software components called actors that interact with each other by exchanging messages (instead of calling methods on interfaces in an object-oriented design), producing a system in which data (instead of control) flows through components to meet the functional requirements of the system.

Amarok Framework Library


This framework library is an attempt to take advantage of the actor/agent programming model for standalone desktop applications. Most of the concepts are inspired by the actor model, Microsoft Robotics CCR and the TPL Dataflow library.

Lite


The intention of the Lite framework is to support actor-based programming in .NET languages. The actor model differs from conventional object-oriented progamming in that objects communicate via asynchronous message-passing instead of method calling.


protoactor-go - Proto Actor - Ultra fast distributed actors for Go, C# and Java/Kotlin


Introducing cross platform actor support between Go and C#.Can I use this? The Go implementation is still in beta, there are users using Proto Actor for Go in production already. But be aware that the API might change over time until 1.0.

frdomain - Code repo for Functional and Reactive Domain Modeling


Code repo for Functional and Reactive Domain Modeling.Functional and Reactive Domain Modeling teaches you how to think of the domain model in terms of pure functions and how to compose them to build larger abstractions. You will start with the basics of functional programming and gradually progress to the advanced concepts and patterns that you need to know to implement complex domain models. The book demonstrates how advanced FP patterns like algebraic data types, typeclass based design, and isolation of side-effects can make your model compose for readability and verifiability. On the subject of reactive modeling, the book focuses on higher order concurrency patterns like actors and futures. It uses the Akka framework as the reference implementation and demonstrates how advanced architectural patterns like event sourcing and CQRS can be put to great use in implementing scalable models. You will learn techniques that are radically different from the standard RDBMS based applications that are based on mutation of records. You'll also pick up important patterns like using asynchronous messaging for interaction based on non blocking concurrency and model persistence, which delivers the speed of in-memory processing along with suitable guarantees of reliability.

Stlab Libraries - C++ Concurrency Library


Stlab Concurrency library provides high level constructs for implementing algorithms that eases the use of multiple CPU cores while minimizing the contention.

nHydrate - Conceive, Model, Generate


nHydrate is an object-relational mapping (ORM) solution for the Microsoft .NET platform providing a framework for a relational database to be mapped to .NET objects. It is designed to alleviate the software developers experience writing persistence domains. The model controls database generation, LINQ syntax, API, DAL, etc.

Artoo - Micro-framework for Robotics using Ruby


Artoo is a micro-framework for robotics using Ruby. It provides a simple, yet powerful Domain-Specific Language (DSL) for robotics and physical computing. It provides next generation robotics framework with support for 15 different platforms. Artoo includes a RESTful API to query the status of any robot running within a group, including the connection and device status, and device streaming data via websockets.

avout - Avout: Distributed State in Clojure


Avout brings Clojure's in-memory model of state to distributed application development by providing a distributed implementation of Clojure's Multiversion Concurrency Control (MVCC) STM along with distributable, durable, and extendable versions of Clojure's Atom and Ref concurrency primitives. Avout enables techniques that require synchronous, coordinated (i.e. transactional) management of distributed state (see also JavaSpaces), complementing approaches that focus on asynchronous, uncoordinated communication between distributed components, e.g. message queues (0MQ, RabbitMQ, HornetQ), event-driven approaches (Netty, Aleph), and actors (Erlang, Akka).

nesC compiler


The nesC language was designed to support the TinyOS project. nesC provides several advantages over C: a component model based on bi-directional interfaces, whole-program compilation for performance and a simple concurrency model for embedded systems.

eventsourced - A library for building reliable, scalable and distributed event-sourced applications in Scala


In other words, Eventsourced implements a write-ahead log (WAL) that is used to keep track of messages an actor receives and to recover its state by replaying logged messages. Appending messages to a log instead of persisting actor state directly allows for actor state persistence at very high transaction rates and supports efficient replication. In contrast to other WAL-based systems, Eventsourced usually keeps the whole message history in the log and makes usage of state snapshots optional. Logged messages represent intended changes to an actor's state. Logging changes instead of updating current state is one of the core concept of event sourcing. Eventsourced can be used to implement event sourcing concepts but it is not limited to that. More details about Eventsourced and its relation to event sourcing can be found at How does Eventsourced persist actor state and how is this related to event sourcing.

Actor Model implementation


CellularAutomatonEngine

Actor Framework for Windows Azure


The goal for ActorFx for Windows Azure is to provide a non-prescriptive, language-independent model of dynamic distributed objects.

Transactional Entity Framework


UNLEASH THE POWER OF PARALLEL COMPUTING WITH AUTOMATIC TRANSACTIONAL MEMORY

Wire - Binary serializer for POCO objects


A high performance polymorphic serializer for the .NET framework. Wire was designed to safely transfer messages in distributed systems, for example service bus or actor model based systems. In message based systems, it is common to receive different types of messages and apply pattern matching over those messages. If the messages does not carry over all the relevant type information to the receiveing side, the message might no longer match exactly what your system expect.

Simple Actor


Simple Actor is simple library for actor-based programming that based on Thread, SynchronizationContext, async/await, and IObservable.