Bitcoin as Backend

Neon Planaria is a new version of Planaria which is completely re-written from scratch.

It is drastically simplified yet exponentially more powerful.

The main design goals are: simplicity and flexibility:

  1. Easy: Easy to use. Minimal syntax. No framework quirks. NO SETUP to get started.
  2. Simple: Minimal framework. Does what it's good at and gets out of the way.
  3. Flexible: Simplicity begets flexibility. Effortless interface with any database system, any library, any 3rd party process, any container.

What it does

Planaria lets you build ANY API backend system from Bitcoin.

The framework is made up of two components:

  1. Planaria: Create an autonomous state machine from Bitcoin. Planaria keeps synchronizing itself with the Bitcoin blockchain and programmatically generates a derivative state machine by using Bitcoin transaction events as command. You can derive ANY state machine you want since Planaria lets you write a JavaScript program to transform and store Bitcoin transactions into any format you want.
  2. Planarium: Create an API endpoint from the generated Planaria state machine. Planarium provides an explorer and an API endpoint, along with a built-in convention to design your own JSON query language like Bitquery.


1. Zero barrier

Neon Planaria is as minimal and as easy as it can get.

No hassle to set up containers, no hassle to worry about ports and firewalls.

No requirement to set up a whole infrastructure and download hundreds of gigabytes of blockchain to do anything, thanks to built-in Bitbus support. (Of course, it also gives the option to plug in a Bitcoin full node later if needed)

It's literally a single node.js app.

All it takes is an npm install, and you're set to go.

2. No limits

Planaria used to have a constrained architecture. It used to be wrapped inside a Docker container, was powered by MongoDB only, and had a quirky & complicated declarative syntax you needed to learn.

Neon Planaria has no such constraints and no limits.

It achieves this goal by throwing away all the bloat which existed in the previous version of Planaria and becoming minimal.

Now you can do whatever you want, including using any Database system..


Planaria can integrate with as many 3rd party technology as possible. You can integrate with any persistence system such as:

  • graph database: Neo4J, Apache Tinkerpop
  • full text index: Elasticsearch, Solr, etc.
  • relational database: PostgreSQL, MySQL, Oracle, etc.
  • key/value database: LevelDB, Redis, etc.
  • Bit data database: HBase, Cassandra, etc.
  • document database: MongoDB
  • decentralized storage: Git, DAT, IPFS, BitTorrent, etc.
  • append only logs/message queue: Kafka, RabbitMQ, ZeroMQ, etc.
  • file storage: S3, etc.

But that's not all. The whole point is that there is no limitation anymore:

No container restrictions

You can employ as many containers as you want concurrently.

For example, you can power ALL of Elasticsearch, MongoDB, and even Kafka from a single Planaria application.

This is made trivial because Planaria itself is no longer a container, but has become an engine that can operate anything, including interacting with multiple containers, executing 3rd party programs, and even making system calls.

Blend into existing workflow

The Planaria part of the framework has two methods: start and exec, and that's it.

  • planaria.start(engine_description) for starting the engine.
  • planaria.exec(cmd, [args]) for making system calls, which can do things like pulling and running a docker container.

You can mix and match with your existing backend or workflow.