Holochain is working toward maturity, and in so doing, is coming to a better understanding of how our code should be organized. We’ve separated the networking repo into its own package, which improves maintainability and speeds up automatic build/test times. This week also brings some low-level features that have no immediate impact on your developer experience, but have big implications for the future. Lastly, we improved error messaging around a previously obscure, but commonly experienced issue.


  1. Architecture/Testing: Signals Updates and Preparing for Changes to DNA Testing
  2. Debugging: Helpful Contextual Logging To `BadCallError`
  3. Internals: Crypto Library Moved Out Of Repository
  4. Challenges: Responding To Incoming Needs


1. Architecture/Testing: Signals Updates and Preparing for Changes to DNA Testing

We’ve made some low-level changes to internal signals. You’ll probably never encounter any of these changes — so why are we announcing them? They lay the foundation for a much more consistent, reliable testing experience for all of us.

Right now, you use our Node.JS conductor when you want to write test for scenarios involving multiple agents for your hApp’s DNA. It’s a library that embeds an entire Holochain runtime so that you can spin up multiple instances of a DNA, each with their own agent IDs.

The problem is that it’s not the actual conductor used in live environments — the differences are subtle but they do show up. This is important for testing DNA code, but it’s absolutely critical for testing Holochain itself.

Therefore, we’re changing the way we do tests in order to keep better consistency. The Node.JS conductor will be removed from the main project and instead, we’ll do our testing with hc-playbook, a Node.JS library that talks to a running conductor via WebSocket. Hc-playbook’s API is nearly identical, so it won’t change much about the way you write tests for your app. We’ll also give you lots of notice about coming changes.

Architecture Abstract

We first have to add features that make it possible for hc-playbook to do all the things that the Node.JS library can do. One of these things is the ability to wait for data to propagate through the DHT before running the next step of the test, which greatly simplifies the testing of real-world, multi-agent scenarios. Therefore, we’re introducing a ‘consistency signal,’ which sends a notification when an event that was expected to happen (such as Bob’s DHT shard receiving Alice’s new entry) finally happens.

Before, we only had trace signals. With the addition of this new signal type, we decided to change the name of the config param that turns tracing signals on and off. What everyone will gain is more consistency between testing and live environments — and one less hard dependency in Holochain Core.

Where does this leave the Node.JS conductor? It’s not going away — we’d like to see it live on as a community project. If you’re interested in taking on maintenance, please talk to us in the Tech Q&A Channel on Mattermost. We’re committed to supporting you through the handover process and beyond.

2. Debugging: Helpful Contextual Logging To `BadCallError`

Some of you have reported `BadCallError` messages — mysterious errors that give you very little clue as to how to fix them. This has created roadblocks for those who have encountered it. So we’ve improved the messaging for these errors to make your life a bit easier. Now you’ll be able to learn whether it was a zome function or a callback (e.g., validation or receive) and the name of the function that failed.

Mysterious Errors

Our goal is to make the development experience top notch. This means helpful error messages, good dev tools, and comprehensive, approachable documentation. This is an ongoing process — there will always be room to improve as Holochain matures. As you experience rough edges, we urge you to submit issues and pull requests to help make things better!

A fix for the issue described above, which involves inaccessible globals in a callback and is in the works for the next version.

3. Internals: Crypto Library Moved Out Of Repository

Holochain is gaining maturity, and with that maturity comes a better understanding of how our code should be organized. It makes sense to put everything into one big codebase at the beginning of a project because the problem space and architectural boundaries haven’t been fully explored. But as the project grows, the lines of modularity become more clear and components naturally separate into their own libraries.

Cryptography and Security ‘Best Practices’

The core and networking projects share common tools provided by libsodium, a battle-tested collection of cryptography and security ‘best practices’ bundled up into a high-performance library. We maintain a wrapper for a Rust port of libsodium; it makes the latter more pleasant to use in Rust projects.

As we shift the networking library to Rust, it makes sense to use that same wrapper, so we’ve separated it into its own package. This improves maintainability and speeds up automatic build/test times.

4. Challenges: Responding To Incoming Needs

Holochain, the idea, is for everyone who values their agency and wants to have control over the software they use and the data they produce.

However Holochain, the app dev framework, is meant for one special group — you — the application developers who will build the things the world has never seen before. This means that we’re here to support you and build the tools you need.

At this early stage, while Holochain is ready for prototypes, but still immature in developer usability, we need to receive a lot of feedback about what works, what’s painful, and what’s missing. This all needs to end up on our ‘state of affairs tree,’ which helps us prioritize our work.

Developer Usability

We’re learning how to receive, interpret, respond to, and execute on all this information. It’s important for your success, which means it’s important for our success. There’s a lot to take in though, and we don’t want to miss anything important, so we’re beginning to map out a process for more direct and consistent community involvement. Once it’s taken shape, we’ll share it and encourage everyone to use it. The main goal is to have the most important needs rise to the top and land directly in our workflow.

We’re an open-source project — we want our community to take ownership, contribute, and help expand the code base. You have the power to help steer Holochain’s course with your input and contributions.

Ultimately, if Holochain works for you, the pioneer species, its popularity will spread like wildfire and pop up all over the internet.

Development Status: