Just released Aqua 0.6.3, a minor update with one syntax addition that's expected to be very useful: collection creation. Now you can use ["hello"] to create a value of type []string, ?[flag!] to create ?bool, and even *[1, 2, 3] to create a stream of numbers. Compiler will try to derive the type of the resulting collection by intersecting all the argument types. See more in the Aqua PR#445.

Aqua 0.6.4 fixes the closures behavior. Now closures, whenever called, execute on the definition site's peer, adding all the necessary topology moves. Previously there was no way to enclose over topology.
If, for any reason, you want to have a "topologically detached" closure, it's still possible with new syntax. See closures documentation for details.

Released Aqua 0.7.0 that is switching FluenceJS Compiler interfaces from v2 to v3. Works only with FluenceJS version 0.21.3 or later – that's a breaking change. It improves JS support for optional Aqua types. Also, all features from the deprecated fldist tool moved to Aqua CLI. All interactions with peer moved to aqua remote subcommand:
aqua remote --help
...
Subcommands:
deploy_service
Deploy service from WASM modules
remove_service
Remove service
create_service
Deploy service from existing blueprint
add_blueprint
Add blueprint to a peer
list_modules
List all modules on a peer
list_blueprints
List all blueprints on a peer
list_interfaces
List all service interfaces on a peer by a given owner
get_interface
Show interface of a service
Descriptions of all commands can be found in Aqua book

As of Aqua 0.7.1, available just now, Aqua supports arithmetic operators (e.g. foo(x+1) ), arrow calls in any place (e.g. for x <- foo(3 + bar()) par...) and simple comparisons (e.g. if a > 3). See the changelog for more.

We are proud to announce the release of Fluence Registry with Aqua Routing API. This is an essential part of the Fluence protocol that provides service advertisement and discovery. Routing API and Registry specify the unified approach to register and resolve services by stable identifiers like IPNS.

To start using Registry, read the documentation.
For more in-depth materials, see our community talk.
See Registry in action on demo presentations (1, 2).

Accompanying the release of Fluence Registry, we are now shipping Signing Service with FluenceJS starting from version v0.21.6. Signing Service allows you to sign arbitrary data with Ed25519 and is quite useful when your Aqua workflow requires signed data or needs to perform signed data verification. Fluence JS Signing Service is a fully interoperable complement to Aqua's builtin signing service.
Please, refer to documentation to learn more about it.

Fluence JS v0.23.0 released!

This update gets one step closer to universal Marine runtime for browser peers on user devices. Now you can execute Wasm services on Fluence JS peers and bring computation to user devices for data privacy use cases and better decentralization.

This is made possible thanks to Marine-JS (milestone 2). The provided API allows hosting marine services on js peer and making them accessible from aqua code. This feature blurs the line between two types of peers and enables service reuse between them.

Please note that a little upgrade is required to switch to v0.23.0.
If you want to learn more - check out the documentation,
and the demo project.

Aqua 0.7.2 complements the recent Fluence JS update.

In addition to updated dependencies and a long list of bugfixes, the release provides new Aqua CLI capabilities, including better JSON data's type derivation for aqua run, array arguments support, and more.

See the full list of changes in the Changelog.

If you thought we took the summer off, think again. The core team's been super busy and has major updates across the stack. Get ready to rev your dependencies.

AquaVM updates

This release includes several major updates of AquaVM, which has achieved a major milestone and is now convergent. That is, AquaVM can merge traces from every possible AIR script. Convergence was achieved by introducing a new instruction canon and a new value type canonicalized stream. The former allows fixing a state of AquaVM's CRDT-like streams at the particular moment of execution on the specific peer producing a canonicalized stream that can be used like an ordinary AIR scalar value. For more info, see the explanation on GitHub.

Please note that the introduction of convergence prohibits using streams in certain positions of AIR instructions, such as a match or call arguments.

The second major improvement concerns the fold operator, whose signature has been extended to support an additional instruction executed on the last step of a recursive next call. This allows carefully adjusted behavior of fold with all combinators. And to make the old scheme with fold par work, the new instruction never has been introduced.

Finally, a lot of bugs have been fixed. See more updates in the change log.

Rust peer updates

Since the last announcements, we have had a lot of updates for Rust Peer.

The Rust peer is now available in three docker flavors: minimal, ipfs, and rich. See the repo for all the images.

- The minimal version provides the Rust Peer executable with builtins, and the curl binary
- The ipfs edition comes with all the features of minimal plus an IPFS daemon
- The rich version provides all the features of the ipfs edition plus Ceramic (Glaze) binaries, the Bitcoin CLI and the Geth CLI.

In addition

- Metrics were added for Wasm services and libp2p in Prometheus
- Logs for Loki were set up
- libp2p was migrated from forked to upstream
- json builtin was added

Fluence CLI updates

For the past months, there has been a lot of work put into Fluence CLI - a tool that makes it easier to work with Fluence Network. We tested the tool on our internal hackathon and found a lot of improvements that can be done, but generally decided that it's almost ready to be used by the developers.

It is designed to manage Fluence decentralized application lifecycle and assist developers. Currently, it can:

- Install all the required dependencies for working with Fluence Network
- Install aqua libraries and help Aqua VSCode plugin to find them
- Store and manage keypairs
- Store and provide ids of the deployed services to aqua and js/ts
- Create services and template modules
- Define deployment config and deploy
- Run and compile Aqua and Marine

The tool is actively developed, and we will soon roll out a lot of updates related to what we found out during the Hackathon (e.g., easier quick start workflow, etc.)

Currently, all the existing docs for Fluence CLI are available in the repo or when running --help with any of the Fluence CLI commands.

Fluence CLI configs are written in YAML format, and info about the configs is currently available only in comments inside of the configs themselves and in JSONSchemas that each config has (you can use redhat.vscode-yaml extension for autocomplete)

Aqua updates

Announcing Aqua 0.7.7

A language server was developed, and we introduced a VSCode extension to support Fluence’s Aqua language. Compile-on-save, compilation error hints, and go-to-definition features were added.

New features in Aqua CLI include:

- Running services directly from CLI
- Running builtin services without any input
- Testing your code with plugins for local js services (experimental!)

Additional advances have been realized in the Aqua compiler:

- AIR generation was updated to support the latest AquaVM version (0.31.0)
- Data structures are now not allowed to have fields of stream type

Also, there were a lot of bug fixes both in CLI and the compiler. See the list of updates.

Fluence JS updates

Fluence JS v0.27.0 was released and the following updates

- Implemented a new builtin json to work with JSON-like structures
- Added v4 version of compiler support making it possible to use any name for functions and data structures in Aqua without colliding with variable names in FluenceJS
- Renamed toB58String to getPeerId for fluence-keypair
- Updated libp2p to v0.36.2

Registry updates

We refactored Registry’s Resources API by removing ambiguous names to make it a bit easier for developer use and to reduce API size. Also, we add the ability to remove service records.
For further details, check out our last community call, README, and API reference, and try Registry and Fluence CLI with a new step-by-step example.

Fluence network updates

We have added end-to-end tests for every build of AquaVM, Marine, Fluence JS, Aqua, Rust Peer, and builtin services, so it will be easier to develop and test every commit. For example, an AquaVM update triggers a rebuild of the whole stack and executes tests in aqua-playground and Registry.

Finally, we have migrated our documentation from Gitbook to Docusaurus.

Also, you can read about our latest updates in this article. Stay tuned!

Hello, Fluencers!

We're about to roll a breaking update to Kras environment.

This release is a step towards native fault tolerant deployments managed from the chain. It brings better performance and introduces Spells: the new feature implementing stateful recurring computations. Spells are services that can be scheduled similarly to cron-jobs and maintain state between executions. Spells are essential to deliver consistent application-specific Subnets (we explain our vision regarding Subnets here https://medium.com/fluence-network/fluence-2022-update-a8a5b0b25f48)

Also the update changes particle data format: now all service call results have a corresponding CID, making the execution content-addressable! It enables better compatibility with content-addressable storage (such as IPFS, Filecoin) and composition with other compute protocols that support CID.

If you use Kras environment, you should update your tools. Here's a list of compatible versions of our tooling and links to changelogs:

rust-peer = 0.0.77 https://github.com/fluencelabs/rust-peer-distro/releases/tag/distro-v0.0.77
aqua = 0.9.4 https://github.com/fluencelabs/aqua/releases/tag/aqua-v0.9.4
fluence-cli = 0.2.37 https://github.com/fluencelabs/fluence-cli/releases/tag/fluence-cli-v0.2.37
fluence-js = 0.28.0 https://github.com/fluencelabs/fluence-js/releases/tag/v0.28.0
marine = 0.12.6 https://github.com/fluencelabs/marine/releases/tag/marine-v0.12.6
mrepl = 0.19.0 https://github.com/fluencelabs/marine/releases/tag/mrepl-v0.19.0

Kindly note that our tooling is compatible with node.js 16.x, and will not work on node.js 18.x.

Computing Marketplace on Testnet

We are excited to announce the launch of Computing Marketplace and fault tolerant deployments on our private testnet. If you are using the latest Fluence CLI, your deployments are rolled out to ad-hoc subnetworks formed from marketplace nodes. You can edit and configure Aqua to manage subnetworks operating workflows and implement failover, load balancing, consensus or other algorithms you need for your app backend.

The testnet is private: community nodes are not yet participating in the marketplace. As we move towards delivery of verifiable proofs of compute, the testnet will be open for any compute providers.

Deployments now require testnet payment to nodes. Get started here to receive testnet tokens from faucet, test it out and provide feedback!

💬 Major Network Update

Hey Fluencers,

A huge update has been rolled out to the Kras network, that includes all the latest features we’re been working on throughout the year. The protocol became more secure, performant, and closer to feature completeness. See about updates below and join the upcoming community call to learn about progress and the roadmap.

Subnets

We are introducing updated subnets: replicated deployments for your applications. Subnets allow to add qualities like fault tolerance, consensus or load balancing to your functions.

Every time you deploy an application to the Fluence network, you are defining a subnet configuration (amount of peers, acceptable pricing, etc) and have your code deployed to specified amount of peers. Subnet peers follow the coordination code that you write in Aqua, which could implement failovers, consensus or quorum algos, load balancing across peers, and any other distributed workflow.

Subnets are tied to on-chain marketplace deals, where all the participating peers and subnet configuration are managed. You can check out deployment quickstart to get some practical knowledge about deploying to subnets.

Fluence Peer (Nox)

We’ve done a significant revamp of the rust-peer, that is now called Nox. We also added arm64/aarch64 support to it, so devs could reliably run development environments on Arm based machines (M-series macs & alike). It is now comes with a set of monitoring and healthcheck http endpoints, so it could be properly run in production grade environments.

Additionally, we’ve introduced the ability to run your own private compute provider or local development environment in order to prepare to join the Fluence Mainnet network and earn by providing their CPU compute capacity after the Mainnet launch.

Please note that we are going remove all the services from Kras environment that were deployed before, so you’ll have to redeploy ’em if you wanna keep using ’em.

Developer Features

- Aqua
- We’ve Added Aqua tracing - we introduce fluence aqua --tracing compiler flag to Fluence CLI, that would augment AIR produced from Aqua with tracing logs that is integrated.
Logs will be inserted on each Aqua function enter and exit. Logs will be sent back to original producer of particle. Be sure to check our aqua changelog
- AIR beautifier tool was included into fluence air commandlet of Fluence CLI that helps to explore compiled air scripts in a human-readable format
- Abilities in Aqua - a way to organise code in modules and implement inversion of control pattern in Aqua.
- Lots of small quality of life improvements
- Marine and MarineJS. Introduced multi-module feature to MarineJS. Now Marine JS re-uses the same code as Rust Marine implementation, only giving it a Wasm VM interface for accessing it via browser.
- Fluence CLI
- Moved our CLI tooling to Node 18.
- CLI automagically checks for updates
- Projects that are scaffolded with Fluence CLI now have detailed annotations in configuration files