It’s been a while since the last Dev Pulse. My commitment to you, dear reader, is that, at a minimum, I always publish a Dev Pulse if there’s a Holochain release with breaking changes. But it turns out that I missed something way back in Holochain 0.0.172! I apologise for the oversight.

You may also have heard that we’ve announced an important date — we’ll be releasing Holochain 0.1.0-beta-rc.0 by December 15th, and we’re asking all devs to write a bunch of tests for their hApps and hammer this RC with those tests. The goal is to discover bugs and stabilise it for the 0.1.0-beta release in January. Read more about how you can help in the official announcement.

Release notes

Holochain 0.0.172: AuthorizeZomeCallSigningKey name change

Release date: 9 November 2022
HDI compatibility: 0.1.8
HDK compatibility: 0.0.160
Breaking changes: admin API, HDI, HDK

Breaking (admin API): The admin API endpoint AuthorizeZomeCallSigningKey had its name and call signature changed, as I warned in the previous Dev Pulse. It’s now called GrantZomeCallCapability to better reflect that it can be used to create any capability grant, not just an assigned one for signing zome calls. As part of this change, the provenance field has also been removed, as it duplicated information already contained in CapAccess::Assigned, which can be used in the payload’s cap_grant.access field. (#1647)

Breaking (HDI/HDK): Wasmer has been updated to 2.3.0. As part of this change, the Holochain wasmer crate has led to simplifications that require fewer .into()s in your HDK code. You probably won’t need to rewrite any code, but you will need to recompile your zomes against HDI 0.1.8 and HDK 0.0.160 because serialisation across the host/guest boundary has changed. (#1620)

Holochain 0.0.173: Network performance tweak #1

Release date: 16 November 2022
HDI compatibility: 0.1.8
HDK compatibility: 0.0.160 and 0.0.161
Breaking changes: none

This release brings the first of a series of experiments to reduce network traffic, timeouts, and deadlocks, which appears to be the primary cause of slow gossip. rpc_multi, a low-level function in the networking layer used to retrieve DHT data, no longer contacts multiple peers. Because it's an experiment, this change may not remain. (#1651)

Holochain 0.0.174: Smaller gossip packets, signals from post_commit

Release date: 23 November 2022
HDI compatibility: 0.1.8 and 0.1.9
HDK compatibility: 0.0.160 to 0.0.162
Breaking changes: network protocol

Breaking (network protocol): To reduce network timeouts, the amount of traffic being transferred in a network message has gotten smaller in two ways:

  • Hard breaking: Entry data can only be 4 MB in size (down from 16 MB to reduce gossip bottlenecks for nodes with slow upload speeds). If your hApp does any blob chunking, it’s time to change the chunk size!
  • Soft breaking: Gossip rounds have a soft limit of 1 MB. This is more of an agreement than an enforced limit, although older conductors will likely have a hard time syncing with this version and newer.


Bug fix (HDK): You can now use emit_signal within your post_commit callbacks, which allows a hApp’s UI to respond to writes triggered by scheduled tasks, calls from other zomes and local cells, and remote calls into a cell from other nodes, as well as simply receive notifications that a locally triggered post-commit has finished. (#1661)

Holochain 0.0.175: Renaming things

Release date: 30 November 2022
HDI compatibility: 0.1.10
HDK compatibility: 0.0.163
Breaking changes: admin API, app API, DNA and hApp manifests, HDI/HDK

Breaking: A number of names related to entry types within a zome, zome indices within a DNA, and DNA roles within a hApp have been changed. (#1667) Here’s the full list:

  • ZomeIdZomeIndex, zome_idzome_index
  • AppEntryType.idAppEntryType.entry_index
  • AppEntryTypeAppEntryDef
  • AppEntryDefNameAppEntryName
  • AppRoleIdRoleName

Read the full changelog.

Getting an hREA node set up: quick start

Connor Turland has posted a quick-start guide for getting a hREA node set up. You can use this as a developer to experiment with the GraphQL API and learn how it works, then start building a UI for the economic coordination app you’ve always wanted to create. ;-)

The instructions are in the hREA Discord (invite link). If you don’t belong to that server, I’ve reprinted them here:

  1. Pre-requirement: have the Rust programming language installed.
  2. Download the hREA hApp file from
  3. Install Holochain Runner:
    cargo install holochain-runner --features db-encryption --version 0.2.0 --locked
    (remove --features db-encryption if you're on Windows)
  4. Run the hApp in the holochain-runner:
    echo SETASECRETPASSPHRASE | holochain-runner --keystore-path /absolute/path/to/a/place/for/your/keystore ./hrea_suite.happ
  5. You're running an hREA node!

For next steps, check out the GraphQL API documentation. If you’re looking to get inspired by hREA makes it easy to create a broad range of economic apps, check out this snippet from a recent Ecosystem Session with Connor.

For a more graphical way to get started, including a web-based GraphQL query runner, check out the official hREA quick start guide.

What’s on the roadmap? Holochain Beta and more

This section is written for developers who are planning the development of their app and need precise details. If that’s not you, here’s the tl;dr: Holochain 0.1.0-beta-rc will be released by 15 December, 0.1.0-beta will be released sometime in January, and it’ll be API-stable and supported for the following six months. Meanwhile, we’re working on performance improvements, security audits, and important components for developers and users. Read the announcement.

The core dev team is working hard to stabilise everything for the upcoming release candidate and the following 0.1.0-beta release. The first release candidate will arrive by 15 December and the beta sometime in January.

0.1.0-beta will have a long-term support (LTS) promise, marking a freeze on all breaking changes and a promise to support hosted discovery services for six months from its release date, as long as you and your users stick to the 0.1.x series. (We may release and support >=0.2.x series in this same timeframe, and you’re welcome to move your app and users to them, but they’ll be separate and parallel and won’t affect our promises for 0.1.x.) This means that you can depend on the stability of the following things within 0.1.x’s LTS period:

  • Network protocol: You won’t have to ask your users to keep upgrading their Holochain version to keep interacting with their friends and colleagues who are using newer versions.
  • Discovery protocols and services: Your users will still be able to find each other, because the bootstrap and proxy protocols won’t change, and Holochain’s hosted bootstrapping and proxying services will keep running.
  • Host API (HDI and HDK): You won’t have to refactor your hApp’s core code to keep up with SDK changes.
  • App API: You won’t have to refactor your hApp’s UI code to keep up with conductor updates.
  • Admin API: If you’re a container creator (e.g., you build something like Launcher, Embedded Holochain Runner, or the Tryorama test framework), you won’t have to refactor your codebase that controls the conductor.

Here’s what’ll be included in 0.1.0-beta (if you’ve been following the project for a while, most of these will be old news).

  • A runtime executable (conductor) and a WebAssembly VM for running the core of your applications
  • An end-user launcher with a built-in app store, available for Windows, macOS, and Linux
  • A secure key store for Holochain-related secrets
  • Developer tools for stubbing, scaffolding, testing, running, and packaging applications, and a development environment based on Nixos that gives you the full suite of Holochain tools and lets you keep all your application’s dependencies pinned — not just Rust libraries but all the binaries too
  • Capability-based security that allows developers to write applications that give their users control over the ways their agency is accessed
  • Source chains for recording individual state changes
  • A peer-to-peer protocol that connects machines into separate, private, TLS-encrypted network spaces
  • A sharded DHT that validates and stores content-addressed graph data, creating a separate distributed database for each network space
  • Composability via bridge function calls between a user’s running applications
  • Remote function calls that allow people to delegate their agency to each other
  • Node-to-node signals that bypass the DHT
  • Countersigning of atomic state changes across multiple parties’ source chains, including a primary witness with M-of-N optional witnesses for building highly available, lightweight consensus
  • Cell cloning for creating new private network spaces with existing applications
  • Quantised gossip and a host of other performance improvements to make both publishing and gossiping faster and more respectful of system resources
  • Integrity and coordinator zomes, for maintaining the core data rules over long periods while issuing updates to controller logic
  • External hash references and Holochain resource locators that allow an application’s graph database to refer to data on other DHTs or outside of Holochain

What are we asking of you?

If you’re developing a hApp, library, tool, or container, we ask you to:

  1. Update your hApp’s zome and client code to work with Holochain 0.1.0-beta-rc when it’s published.
  2. Run all your tests against the upcoming release candidates (if you haven’t written tests yet, Tryorama is a JavaScript-based scenario testing framework, and Sweettest is a Rust-based framework that comes with the holochain crate and allows you to mock certain parts of the Holochain stack).
  3. Report any errors or developer UX problems you find as GitHub issues.

If you’d like to get more involved in the development conversation, remember we have a Discord server for you.

What does this mean for Holo hosting?

As one of the primary groups developing on Holochain, the Holo hosting team is eager to have stable, full-featured releases on which to build HoloFuel, Service Logger, and all the hApps to support hosts and publishers. This milestone will allow them to move more confidently, which will translate to more rapid movement.

In addition, they’ve been rewriting their Holo Web SDK to align more closely with the API of the Holochain JavaScript client. This will mean that it’ll be easier for you to get your hApps ready for pre-beta testing on the hosting network.

What will happen after this?

Here are some roadmap items that won’t be part of 0.1.0-beta. We'll also be updating the roadmap and adding more details beyond the 0.1.x-beta milestone.

  • Immune system / warranting to identify and take action against bad actors
  • Ephemeral store for storing non-source-chain data that can be removed later
  • Merkle tree entries that provide public proofs of the existence of private data, which can be selectively disclosed to those who ask for it
  • Pub/sub signals which allows nodes to selectively listen for messages and DHT events by topic
  • A new large-scale testing framework, which allows developers to spin up >100k nodes across multiple machines and run automated test scenarios
  • Attack Factory, a library of common threat scenarios that can be played against your hApp to test it for vulnerabilities

Holochain 0.2.0, the ‘network stable’ beta, will include the immune system, end-to-end encryption, a new transport protocol based on WebRTC and TURN, and potentially other features from the list above. It will likely come out while the 0.1.x series is being supported, and will carry its own separate six-month long-term-support promise.

Not all point release bumps (e.g., 0.2.x, 0.3.x) will contain breaking changes for the things you touch as a developer, so you may find that your hApp will work just fine on the next point version.

Happening in parallel

In the meantime, things are happening in the larger ecosystem. In the coming months, you can expect further performance improvements, a revamped scaffolding tool (similar to the famous Rails scaffolder), as well as useful core libraries like DeepKey. Various dev teams will be sharing their rollout plans soon.

Let’s go!

I’m not gonna lie — I’m really excited for this next phase of Holochain’s journey. I know that existing hApp developers are looking forward to things quieting down (although new features are cool too), and I’ve also talked to app developers who are waiting for this stage of maturity before they start devoting time to building on Holochain. It feels like there’s a lot of energy just waiting for this moment, which is fast approaching.

If you want to know more, read the official announcement from the Holochain Foundation and take a look at the Holochain roadmap.

Cover photo by Pascal Meier on Unsplash