Visit my Github to read more technical info and test the demo app, currently you have to compile from source. Binary releases will be provided as soon as all baseline features are in place.

What is Colony?

Colony is a native cross-platform (Linux, Windows, Mac) desktop application written in Rust leveraging the Slint GUI framework. It enables users to upload, download, share, and search for files on the Autonomi network. There are no servers, no oracles, and no curated databases of information.

The goal of Colony is to make the Autonomi network successful. The most successful network on the internet is undoubtedly the WWW. What made the WWW successful 30 years ago was the search engine and its ubiquitous search bar. But the WWW is based on servers and clients. Servers know everything there is to know and can respond to client requests, but with Autonomi, we have no such such server, so how do we get our search bar?

How it works

Like Autonomi, Colony leverages a small set of rules and applies the concept of emergence. The concept can be described like this:

• Upload files

• Write metadata about files to a publically readable scratchpad called a pod in RDF

• Share this pod address with your friends

• Add your friends' pod addresses to your pod

With only a few addresses per user, this friend of a friend of a friend topology will build up a dynamically generated manifest of all collateral on the network, without a server or all knowing oracle. Users of Colony will automatically create a metadata layer to Autonomi, enabling client side search operations, without a middle man.

Because the user created metadata is in scratchpads:

• Metadata can be appended, modified, refactored, or deleted at 0 cost once created.

• The user owns the data fully and is in control. Share some pods with some users, but not others. Or don't share certain pods at all for personal data.

• Data is portable to any other application using the same metadata concept. No lock in!

Like modern crypto wallets, Colony leverages a 12 word seed phrase generated master key that it uses to derive keys for all generated pod scratchpads. To recover all of your data or work with it in another application, all you need is your 12 word seed phrase.

Status of Colony

Colony has been in daily development for the last month. The demo app currently does the following:

• GUI skeleton written in Slint UI

• Installation GUI procedure complete

• Generate a master key from an input or auto generated BIP39 compliant seed phrase

• Generate configuration file

• Import ETH private key and fetch Arbitrum ETH/ANT balances from the network

• Encrypt all private keys within a password protected cocoon

• Connects to the Autonomi network

Next steps:

• Generate metadata scratchpad pods from input fields (1 week)

• Upload files and metadata pods to Autonomi alpha network (2 weeks)

• Download files from Autonomi using information from pods (2 weeks)

• And then SEARCH!! (2 weeks)

High level: The boilerplate code and learning Rust in general is in place. Ready to start plugging in the core network features!

Bonus features to be added after the Impossible Futures challenge (or before if there is time!):

• Automatic metadata populate from open data sources like OMDb, MusicBrainz, and OpenLibrary

• Create API to connect a 3rd party local AI agent to handle metadata queries

• Build a server mode for Colony to enable self hosting in a docker image and develop a web application for interacting with your Colony instance anywhere you have a web browser.

• Build a Colony mobile client for Android and IPhone to connect to a self hosted server

• Have another idea for an add-on? Let me know on discord or the Autonomi Forum!

Scaling and Thoughts on the Future

Leveraging metadata in this way is a force multiplier, but eventually Colony will run into scalability issues. A home desktop just won't have the capabilty to handle searches on massive datasets. How many files can we reasonably track? Some fuzzy math:

• Assume 2KB of metadata on average per file

• Scratchpads are 4MB in size, but assume 5% overhead for pod duplication, syntax, etc.

This calculates to a metadata to storage ratio of 475 files/MB. What would it take for Colony to index all of the Internet Archive's files?:

• 44 million books and texts

• 15 million audio recordings

• 10.6 million videos

• 4.8 million images

• 1 million software programs

Or about 75 million files in total. Based on the back of the napkin calculation above, it would take about 160GB of disk space to index the entirety of the Internet Archive's 145 PBs of file data. A hefty desktop would be required, but it wouldn't be impossible to self host.

By the time we get to a cache size of hundreds of GB on Autonomi, a distributed search mechanism will be implemented to parse the database, or better, AI agents will exist within Autonomi itself leveraging this dataset and responding to queries from users. It is a future concern, but I have no doubt a future genius will figure out a solution.

About the developer

I am a 15 year veteran of the semiconductor industry, working in design, verification, and implementation. I've published and presented 4 papers at the Design and Verification Conference (DVCon), winning the Stuart Sutherland Best Paper Presentation award in 2023 for my paper on a novel real number modelling and verification framework in SystemVerilog. I contributed to the IEEE 1800.2023 SystemVerilog standard, writing the real constraints and coverage section. I am also a lead contributor to the Accellera SystemVerilog Mixed Signal Interface committee, which is in the process of developing an automated signal type adaptation system for SystemVerilog. In 2009 before starting my career, I hiked the entirety of the 2100 mile Appalachian Trail, even after suffering a back injury that took me off the trail for 6 weeks. To put it simply, when I set my mind to doing something, I get the job done. I am a life long tinkerer, builder, and maker, living on my homestead in east Tennessee with my beautiful wife of 15 years, 3 free-range kids, and an old dog that has an uncanny ability to find skunks.

Conclusion

The end goal for Colony isn’t to be the end-all app for Autonomi. It is simply the first application using the metadata scheme above, setting up a framework and serving as a model for other apps to leverage in the future. The hope is that other Autonomi apps will leverage this framework, enabling us all to benefit from the ability to seamlessly move between apps and search for data in a common way.

For any app developers out there, if you want to leverage the same metadata and seed generation concepts in your own apps, send me a message! I'm happy to help where I can.

Please consider dropping some ANT on Colony! Thank you for your consideration!